// 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');
            router.account = router.project;
        }

        if (router.vpcid) {
            routerType = _l('label.vpc');
            router.guestnetworkname = router.vpcname;
        }

        if (router.isredundantrouter) {
            router.guestnetworkname = router.guestnetworkname + " (" + router.redundantstate + ")";
        }

        return $.extend(router, {
            routerType: routerType
        });
    };

    cloudStack.publicIpRangeAccount = {
        dialog: function (args) {
            return function (args) {
                var data = args.data ? args.data: {
                };
                var fields = {
                    systemvms: {
                        label: 'label.system.vms',
                        isBoolean: true,
                        docID: 'helpSetReservationSystemVms',
                        defaultValue: data.systemvms
                    },
                    account: {
                        label: 'label.account',
                        defaultValue: data.account
                    },
                    domainid: {
                        label: 'label.domain',
                        defaultValue: data.domainid,
                        select: function (args) {
                            $.ajax({
                                url: createURL('listDomains'),
                                data: {
                                    details: 'min',
                                    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,
                            details: 'min',
                            listAll: true
                        },
                        success: function (json) {
                            var domain = json.listdomainsresponse.domain[0];

                            if (data.forSystemVms != null) {
                                systemvms = '<li>' + _l('label.system.vms') + ': ' + data.forSystemVms + '</li>'
                            }
                            if (data.account != null)
                                cloudStack.dialog.notice({
                                    message: '<ul><li>' + _l('label.account') + ': ' + data.account + '</li>' + '<li>' + _l('label.domain') + ': ' + domain.path + '</li>' + systemvms + '</ul>'
                                });
                            else
                                cloudStack.dialog.notice({
                                    message: '<ul><li>' + _l('label.domain') + ': ' + domain.path + '</li>' + systemvms + '</ul>'
                                });
                        }
                    });
                } else {
                    cloudStack.dialog.createForm({
                        form: {
                            title: 'label.set.reservation',
                            desc: 'label.set.reservation.desc',
                            fields: fields,
                            preFilter: function(args) {
                                var $systemvms = args.$form.find('.form-item[rel=systemvms]');
                                var $systemvmsCb = $systemvms.find('input[type=checkbox]');
                                var $account = args.$form.find('.form-item[rel=account]');
                                var $accountTxt = args.$form.find('input[name=account]');
                                var $domainid = args.$form.find('select[name=domainid]');
                                $systemvmsCb.change(function() {
                                    if ($systemvmsCb.is(':checked')) {
                                        $accountTxt.val('');
                                        $accountTxt.attr('disabled', true);
                                        $domainid.attr('disabled', true);
                                    }
                                    else {
                                        $accountTxt.attr('disabled', false);
                                        $domainid.attr('disabled', false);
                                    }
                                });
                            }
                        },
                        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 = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.kvmnetworklabel == null || trafficType.kvmnetworklabel == 0)
        trafficType.kvmnetworklabel = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.vmwarenetworklabel == null || trafficType.vmwarenetworklabel == 0)
        trafficType.vmwarenetworklabel = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.ovmnetworklabel == null || trafficType.ovmnetworklabel == 0)
        trafficType.ovmnetworklabel = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.lxcnetworklabel == null || trafficType.lxcnetworklabel == 0)
        trafficType.lxcnetworklabel = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.hypervnetworklabel == null || trafficType.hypervnetworklabel == 0)
        trafficType.hypervnetworklabel = _l( 'label.network.label.display.for.blank.value');
        if (trafficType.ovm3networklabel == null || trafficType.ovm3networklabel == 0)
        trafficType.ovm3networklabel = _l( 'label.network.label.display.for.blank.value');

        return trafficType;
    };

    var updateTrafficLabels = function (trafficType, labels, complete) {
        var array1 =[];
        if (labels.xennetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&xennetworklabel=" + labels.xennetworklabel);
        if (labels.kvmnetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&kvmnetworklabel=" + labels.kvmnetworklabel);
        if (labels.vmwarenetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&vmwarenetworklabel=" + labels.vmwarenetworklabel);
        if (labels.ovmnetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&ovmnetworklabel=" + labels.ovmnetworklabel);
        if (labels.lxcnetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&lxcnetworklabel=" + labels.lxcnetworklabel);
        if (labels.hypervnetworklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&hypervnetworklabel=" + labels.hypervnetworklabel);
        if (labels.ovm3networklabel != _l( 'label.network.label.display.for.blank.value'))
        array1.push("&ovm3networklabel=" + labels.ovm3networklabel);

        $.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;
    };

    function ovsProviderActionFilter(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;
    };

    var rollingMaintenanceAction = function(args) {
        var isCluster = args.entity === 'clusters';
        var isZone = args.entity === 'zones';
        var isPod = args.entity === 'pods';
        var isHost = args.entity === 'hosts';
        var action = {
            messages: {
                notification: function(args) {
                    return 'label.start.rolling.maintenance';
                }
            },
            label: 'label.start.rolling.maintenance',
            addRow: 'false',
            createForm: {
                title: 'label.start.rolling.maintenance',
                fields: {
                    timeout: {
                        label: 'label.timeout',
                    },
                    force: {
                        isBoolean: true,
                        label: 'label.start.rolling.maintenance.force'
                    },
                    payload: {
                        label: 'label.start.rolling.maintenance.payload'
                    }
                }
            },
            action: function(args) {
                var selectedIds;
                if (isCluster) {
                    selectedIds = args.context.clusters.map(x => x.id);
                } else if (isZone) {
                    selectedIds = args.context.physicalResources.map(x => x.id);
                } else if (isPod) {
                    selectedIds = args.context.pods.map(x => x.id);
                } else if (isHost) {
                    selectedIds = args.context.hosts.map(x => x.id);
                }
                var ids = selectedIds.join(',');
                var data = {
                    force: args.data.force,
                    timeout: args.data.timeout,
                    payload: args.data.payload
                };
                if (isCluster) {
                    $.extend(data, {
                        clusterids : ids
                    });
                } else if (isZone) {
                    $.extend(data, {
                        zoneids : ids
                    });
                } else if (isPod) {
                    $.extend(data, {
                        podids : ids
                    });
                } else if (isHost) {
                    $.extend(data, {
                        hostids : ids
                    });
                }

                $.ajax({
                    url: createURL("startRollingMaintenance"),
                    dataType: "json",
                    data: data,
                    async: true,
                    success: function (json) {
                        var item = json.startrollingmaintenanceresponse;
                        var jid = item.jobid;
                        args.response.success({
                            _custom: {
                                jobId: jid
                            }
                        });
                    }
                });
            },
            notification: {
                poll: pollAsyncJobResult
            }
        };

        if (args && args.listView) {
            $.extend(action, {
                isHeader: true,
                isMultiSelectAction: true
            });
        }

        return action;
    };

    cloudStack.sections.system = {
        title: 'label.menu.infrastructure',
        id: 'system',

        // System dashboard
        dashboard: {
            dataProvider: function (args) {
                $.ajax({
                    url: createURL('listInfrastructure'),
                    success: function (json) {
                        var response = json.listinfrastructureresponse.infrastructure;
                        var data = {};
                        data.zoneCount = response.zones;
                        data.podCount = response.pods;
                        data.clusterCount = response.clusters;
                        data.hostCount = response.hosts;
                        data.primaryStorageCount = response.storagepools;
                        data.secondaryStorageCount = response.imagestores;
                        data.systemVmCount = response.systemvms;
                        data.virtualRouterCount = response.routers;
                        data.socketCount = response.cpusockets;
                        data.managementServerCount = response.managementservers;
                        args.response.success({
                            data: data
                        });
                    }
                });
            }
        },

        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'
                        }
                    }
                },
                disableInfiniteScrolling: true,
                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.xenserver.traffic.label',
                                        isEditable: true
                                    },
                                    kvmnetworklabel: {
                                        label: 'label.kvm.traffic.label',
                                        isEditable: true
                                    },
                                    vmwarenetworklabel: {
                                        label: 'label.vmware.traffic.label',
                                        isEditable: true
                                    },
                                    ovmnetworklabel: {
                                        label: 'label.ovm.traffic.label',
                                        isEditable: true
                                    },
                                    lxcnetworklabel: {
                                        label: 'label.lxc.traffic.label',
                                        isEditable: true
                                    },
                                    hypervnetworklabel: {
                                        label: 'label.hyperv.traffic.label',
                                        isEditable: true
                                    },
                                    ovm3networklabel: {
                                        label: 'label.ovm3.traffic.label',
                                        isEditable: true
                                    }
                                }],

                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listNetworks&listAll=true&trafficType=Public&isSystem=true&zoneId=" + selectedZoneObj.id, {
                                            ignoreProject: true
                                        }),
                                        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;
                                            selectedPublicNetworkObj.lxcnetworklabel = trafficType.lxcnetworklabel;
                                            selectedPublicNetworkObj.hypervnetworklabel = trafficType.hypervnetworklabel;
                                            selectedPublicNetworkObj.ovm3networklabel = trafficType.ovm3networklabel;
                                            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.set.reservation',
                                                    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);

                                                var vlan = "untagged";
                                                if (args.data.vlan != null && args.data.vlan.length > 0){
                                                    vlan = args.data.vlan;
                                                }
                                                cloudStack.addVlanToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, vlan);

                                                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) {
                                                    if (args.data.account.account)
                                                        array1.push("&account=" + args.data.account.account);
                                                        if (args.data.account.domainid) {
                                                            array1.push("&domainid=" + args.data.account.domainid);
                                                        }
                                                    if (args.data.account.systemvms) {
                                                        systvmsval = args.data.account.systemvms == "on" ? "true" : "false"
                                                        array1.push("&forsystemvms=" + systvmsval);
                                                    }
                                                }

                                                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);
                                                    }
                                                });
                                            }
                                        },
                                        actionPreFilter: function (args) {
                                            var actionsToShow =[ 'destroy'];
                                            if (args.context.multiRule[0].domain == 'ROOT' && args.context.multiRule[0].account != null &&
                                                args.context.multiRule[0].account.account == 'system' && !args.context.multiRule[0].forsystemvms)
                                            actionsToShow.push('addAccount'); else
                                            actionsToShow.push('releaseFromAccount');
                                            return actionsToShow;
                                        },
                                        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));
                                                        }
                                                    });
                                                }
                                            },

                                            releaseFromAccount: {
                                                label: 'label.release.account',
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('releasePublicIpRange'),
                                                        data: {
                                                            id: args.context.multiRule[0].id
                                                        },
                                                        success: function (json) {
                                                            args.response.success({
                                                                notification: {
                                                                    label: 'label.release.account.lowercase',
                                                                    poll: function (args) {
                                                                        args.complete();
                                                                    }
                                                                }
                                                            });
                                                        },
                                                        error: function (json) {
                                                            args.response.error(parseXMLHttpResponse(json));
                                                        }
                                                    });
                                                }
                                            },

                                            addAccount: {
                                                label: 'label.add.account',
                                                createForm: {
                                                    title: 'label.add.account',
                                                    fields: {
                                                        account: {
                                                            label: 'label.account'
                                                        },
                                                        domainid: {
                                                            label: 'label.domain',
                                                            select: function (args) {
                                                                $.ajax({
                                                                    url: createURL('listDomains'),
                                                                    data: {
                                                                        details: 'min',
                                                                        listAll: true
                                                                    },
                                                                    success: function (json) {
                                                                        args.response.success({
                                                                            data: $.map(json.listdomainsresponse.domain, function (domain) {
                                                                                return {
                                                                                    id: domain.id,
                                                                                    description: domain.path
                                                                                };
                                                                            })
                                                                        });
                                                                    }
                                                                });
                                                            }
                                                        }
                                                    }
                                                },
                                                action: function (args) {
                                                    var data = {
                                                        id: args.context.multiRule[0].id,
                                                        zoneid: args.context.multiRule[0].zoneid,
                                                        domainid: args.data.domainid
                                                    };
                                                    if (args.data.account) {
                                                        $.extend(data, {
                                                            account: args.data.account
                                                        });
                                                    }
                                                    $.ajax({
                                                        url: createURL('dedicatePublicIpRange'),
                                                        data: data,
                                                        success: function (json) {
                                                            args.response.success({
                                                                notification: {
                                                                    label: 'label.add.account',
                                                                    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 ? '[' + item.domain + '] ' + item.account: item.domain,
                                                                    account: item.account,
                                                                    domainid: item.domainid,
                                                                    forSystemVms: item.forsystemvms
                                                                }
                                                            });
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                },

                '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.xenserver.traffic.label',
                                        isEditable: true
                                    },
                                    kvmnetworklabel: {
                                        label: 'label.kvm.traffic.label',
                                        isEditable: true
                                    },
                                    vmwarenetworklabel: {
                                        label: 'label.vmware.traffic.label',
                                        isEditable: true
                                    },
                                    ovmnetworklabel: {
                                        label: 'label.ovm.traffic.label',
                                        isEditable: true
                                    },
                                    lxcnetworklabel: {
                                        label: 'label.lxc.traffic.label',
                                        isEditable: true
                                    },
                                    hypervnetworklabel: {
                                        label: 'label.hyperv.traffic.label',
                                        isEditable: true
                                    },
                                    ovm3networklabel: {
                                        label: 'label.ovm3.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;
                                            selectedPublicNetworkObj.lxcnetworklabel = trafficType.lxcnetworklabel;
                                            selectedPublicNetworkObj.hypervnetworklabel = trafficType.hypervnetworklabel;
                                            selectedPublicNetworkObj.ovm3networklabel = trafficType.ovm3networklabel;
                                            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);

                                                cloudStack.addVlanToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, 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),
                                                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.xenserver.traffic.label',
                                        isEditable: true
                                    },
                                    kvmnetworklabel: {
                                        label: 'label.kvm.traffic.label',
                                        isEditable: true
                                    },
                                    vmwarenetworklabel: {
                                        label: 'label.vmware.traffic.label',
                                        isEditable: true
                                    },
                                    ovmnetworklabel: {
                                        label: 'label.ovm.traffic.label',
                                        isEditable: true
                                    },
                                    lxcnetworklabel: {
                                        label: 'label.lxc.traffic.label',
                                        isEditable: true
                                    },
                                    hypervnetworklabel: {
                                        label: 'label.hyperv.traffic.label',
                                        isEditable: true
                                    },
                                    ovm3networklabel: {
                                        label: 'label.ovm3.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;
                                            selectedManagementNetworkObj.lxcnetworklabel = trafficType.lxcnetworklabel;
                                            selectedManagementNetworkObj.hypervnetworklabel = trafficType.hypervnetworklabel;
                                            selectedManagementNetworkObj.ovm3networklabel = trafficType.ovm3networklabel;
                                            args.response.success({
                                                data: selectedManagementNetworkObj
                                            });
                                        }
                                    });
                                }
                            },

                            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
                                                                });
                                                            });
                                                            args.response.success({
                                                                data: items
                                                            });
                                                        }
                                                    });
                                                }
                                            },
                                            'gateway': {
                                                edit: true,
                                                label: 'label.gateway'
                                            },
                                            'netmask': {
                                                edit: true,
                                                label: 'label.netmask'
                                            },
                                            'vlan': {
                                                edit: true,
                                                label: 'label.vlan',
                                                validation: {
                                                    required: false
                                                }
                                            },
                                            'startip': {
                                                edit: true,
                                                label: 'label.start.IP'
                                            },
                                            'endip': {
                                                edit: true,
                                                label: 'label.end.IP',
                                                validation: {
                                                    required: false
                                                }
                                            },
                                            'systemvms' : {
                                                isBoolean: true,
                                                label: 'label.system.vms'
                                            },
                                            'add-rule': {
                                                label: 'label.add',
                                                addButton: true
                                            }
                                        },
                                        add: {
                                            label: 'label.add',
                                            action: function (args) {
                                                var array1 =[];

                                                array1.push("&podid=" + args.data.podid);
                                                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.systemvms) {
                                                    array1.push("&forsystemvms=" + (args.data.systemvms == "on" ? "true" : "false"));
                                                }
                                                cloudStack.addVlanToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.vlan);

                                                $.ajax({
                                                    url: createURL("createManagementNetworkIpRange" + array1.join("")),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: json.createmanagementnetworkiprangeresponse.jobid
                                                            },
                                                            notification: {
                                                                label: 'label.add.management.ip.range',
                                                                poll: pollAsyncJobResult
                                                            }
                                                        });
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        args.response.error(errorMsg);
                                                    }
                                                });
                                            }
                                        },
                                        actions: {
                                            destroy: {
                                                label: 'label.delete',
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&podid=" + args.context.multiRule[0].podid);
                                                    array1.push("&startip=" + args.context.multiRule[0].startip);
                                                    array1.push("&endip=" + args.context.multiRule[0].endip);
                                                    array1.push("&vlan=" + args.context.multiRule[0].vlan);

                                                    $.ajax({
                                                        url: createURL('deleteManagementNetworkIpRange' + array1.join("")),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: json.deletemanagementnetworkiprangeresponse.jobid
                                                                },
                                                                notification: {
                                                                    label: 'label.remove.management.ip.range',
                                                                    poll: pollAsyncJobResult
                                                                }
                                                            });
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            args.response.error(errorMsg);
                                                        }
                                                    });
                                                }
                                            }
                                        },
                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL("listPods&zoneid=" + selectedZoneObj.id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var items =[];

                                                    var pods = json.listpodsresponse.pod;
                                                    $(pods).each(function () {
                                                        for (var i = 0; i < this.startip.length; i++) {
                                                            var systemvmsValue = this.forsystemvms[i] == "1" ? true : false;
                                                            items.push({
                                                                podid: this.id,
                                                                gateway: this.gateway,
                                                                netmask: this.netmask,
                                                                startip: this.startip[i],
                                                                endip: this.endip[i],
                                                                systemvms: systemvmsValue,
                                                                vlan: this.vlanid[i]
                                                            });
                                                        }
                                                    });

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

                'guest': {
                    //physical network + Guest traffic type
                    detailView: {
                        actions: {
                            edit: {
                                label: 'label.edit',
                                action: function (args) {
                                    var data = {
                                        id: selectedPhysicalNetworkObj.id
                                    };

                                    $.extend(data, {
                                        vlan: args.data.vlan
                                    });

                                    $.extend(data, {
                                        tags: args.data.tags
                                    });

                                    $.ajax({
                                        url: createURL('updatePhysicalNetwork'),
                                        data: data,
                                        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");
                                hiddenTabs.push("dedicatedGuestVlanRanges");
                            } 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("vlan");
                                        // hiddenFields.push("endVlan");
                                    }
                                    return hiddenFields;
                                },
                                fields:[ {
                                    //updatePhysicalNetwork API
                                    state: {
                                        label: 'label.state'
                                    },
                                    vlan: {
                                        label: 'label.vlan.vni.ranges',
                                        isEditable: true
                                    },
                                    tags: {
                                        label: 'label.tags',
                                        isEditable: true
                                    },
                                    broadcastdomainrange: {
                                        label: 'label.broadcast.domain.range'
                                    }
                                },
                                {
                                    //updateTrafficType API
                                    xennetworklabel: {
                                        label: 'label.xenserver.traffic.label',
                                        isEditable: true
                                    },
                                    kvmnetworklabel: {
                                        label: 'label.kvm.traffic.label',
                                        isEditable: true
                                    },
                                    vmwarenetworklabel: {
                                        label: 'label.vmware.traffic.label',
                                        isEditable: true
                                    },
                                    ovmnetworklabel: {
                                        label: 'label.ovm.traffic.label',
                                        isEditable: true
                                    },
                                    lxcnetworklabel: {
                                        label: 'label.lxc.traffic.label',
                                        isEditable: true
                                    },
                                    hypervnetworklabel: {
                                        label: 'label.hyperv.traffic.label',
                                        isEditable: true
                                    },
                                    ovm3networklabel: {
                                        label: 'label.ovm3.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 xenservertrafficlabel, 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;
                                            selectedPhysicalNetworkObj[ "lxcnetworklabel"] = trafficType.lxcnetworklabel;
                                            selectedPhysicalNetworkObj[ "hypervnetworklabel"] = trafficType.hypervnetworklabel;
                                            selectedPhysicalNetworkObj[ "ovm3networklabel"] = trafficType.ovm3networklabel;
                                            args.response.success({
                                                actionFilter: function () {
                                                    var allowedActions =[ 'edit', 'addVlanRange', 'removeVlanRange'];
                                                    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
                                                            });
                                                        }
                                                    });
                                                }
                                            },
                                            'gateway': {
                                                edit: true,
                                                label: 'label.gateway'
                                            },
                                            'netmask': {
                                                edit: true,
                                                label: 'label.netmask'
                                            },
                                            '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("&podid=" + args.data.podid);
                                                array1.push("&networkid=" + selectedGuestNetworkObj.id);
                                                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);
                                                array1.push("&forVirtualNetwork=false");
                                                //indicates this new IP range is for guest network, not public 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) {
                                            //only basic zone has IP Range tab
                                            selectedGuestNetworkObj = null;
                                            $.ajax({
                                                url: createURL("listNetworks&listAll=true&trafficType=Guest&zoneid=" + selectedZoneObj.id),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    var items = json.listnetworksresponse.network;
                                                    if (items != null && items.length > 0)
                                                    selectedGuestNetworkObj = json.listnetworksresponse.network[0];
                                                }
                                            });
                                            if (selectedGuestNetworkObj == null)
                                            return;

                                            $.ajax({
                                                url: createURL("listVlanIpRanges&zoneid=" + selectedZoneObj.id + "&networkId=" + selectedGuestNetworkObj.id),
                                                dataType: "json",
                                                success: function (json) {
                                                    var items = json.listvlaniprangesresponse.vlaniprange;
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    });
                                }
                            },

                            network: {
                                title: 'label.network',
                                listView: {
                                    section: 'networks',
                                    id: 'networks',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        type: {
                                            label: 'label.type'
                                        },
                                        vlan: {
                                            label: 'label.vnet.id'
                                        },
                                        broadcasturi: {
                                            label: 'label.broadcat.uri'
                                        },
                                        cidr: {
                                            label: 'label.ipv4.cidr'
                                        },
                                        ip6cidr: {
                                            label: 'label.ipv6.CIDR'
                                        }
                                        //scope: { label: 'label.scope' }
                                    },
                                    actions: {
                                        add: addGuestNetworkDialog.def
                                    },

                                    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;
                                                }
                                            }
                                        }

                                        //need to make 2 listNetworks API call to get all guest networks from one physical network in Advanced zone
                                        var items =[];
                                        //"listNetworks&projectid=-1": list guest networks under all projects (no matter who the owner is)
                                        $.ajax({
                                            url: createURL("listNetworks&projectid=-1&trafficType=Guest&zoneId=" + selectedZoneObj.id + "&physicalnetworkid=" + selectedPhysicalNetworkObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            dataType: "json",
                                            async: false,
                                            success: function (json) {
                                                if (json.listnetworksresponse.network != null && json.listnetworksresponse.network.length > 0)
                                                items = json.listnetworksresponse.network;
                                            }
                                        });

                                        var networkCollectionMap = {
                                        };
                                        $(items).each(function () {
                                            networkCollectionMap[ this.id] = this.name;
                                        });

                                        //"listNetworks&listAll=true: list guest networks that are not under any project (no matter who the owner is)
                                        $.ajax({
                                            url: createURL("listNetworks&listAll=true&trafficType=Guest&zoneId=" + selectedZoneObj.id + "&physicalnetworkid=" + selectedPhysicalNetworkObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            dataType: "json",
                                            async: false,
                                            success: function (json) {
                                                $(json.listnetworksresponse.network).each(function () {
                                                    if ((this.id in networkCollectionMap) == false)
                                                    items.push(this);
                                                });
                                            }
                                        });

                                        $(items).each(function () {
                                            addExtraPropertiesToGuestNetworkObject(this);
                                        });

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

                                    detailView: {
                                        name: 'label.guest.network.details',
                                        noCompact: true,
                                        viewAll: {
                                            path: '_zone.guestIpRanges',
                                            label: 'label.ip.ranges',
                                            preFilter: function (args) {
                                                if (selectedGuestNetworkObj.type == "Isolated") {
                                                    var services = selectedGuestNetworkObj.service;
                                                    if (services != null) {
                                                        for (var i = 0; i < services.length; i++) {
                                                            var service = services[i];
                                                            if (service.name == "SourceNat")
                                                            return false;
                                                        }
                                                    }
                                                }
                                                return true;
                                            }
                                        },
                                        actions: {
                                            edit: {
                                                label: 'label.edit',
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&name=" + encodeURIComponent(args.data.name));
                                                    array1.push("&displaytext=" + encodeURIComponent(args.data.displaytext));

                                                    //args.data.networkdomain is null when networkdomain field is hidden
                                                    if (args.data.networkdomain != null && args.data.networkdomain != selectedGuestNetworkObj.networkdomain)
                                                    array1.push("&networkdomain=" + encodeURIComponent(args.data.networkdomain));

                                                    //args.data.networkofferingid is null when networkofferingid field is hidden
                                                    if (args.data.networkofferingid != null && args.data.networkofferingid != args.context.networks[0].networkofferingid) {
                                                        array1.push("&networkofferingid=" + encodeURIComponent(args.data.networkofferingid));

                                                        if (args.context.networks[0].type == "Isolated") {
                                                            //Isolated network
                                                            cloudStack.dialog.confirm({
                                                                message: 'message.confirm.current.guest.CIDR.unchanged',
                                                                action: function () {
                                                                    //"Yes"    button is clicked
                                                                    array1.push("&changecidr=false");
                                                                    $.ajax({
                                                                        url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")),
                                                                        dataType: "json",
                                                                        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
                                                                    array1.push("&changecidr=true");
                                                                    $.ajax({
                                                                        url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")),
                                                                        dataType: "json",
                                                                        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;
                                                        }
                                                    }

                                                    $.ajax({
                                                        url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")),
                                                        dataType: "json",
                                                        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
                                                                        };
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            'restart': {
                                                label: 'label.restart.network',
                                                createForm: {
                                                    title: 'label.restart.network',
                                                    desc: 'message.restart.network',
                                                    preFilter: function (args) {
                                                        if (selectedZoneObj.networktype == "Basic") {
                                                            args.$form.find('.form-item[rel=cleanup]').find('input').prop('checked', false);
                                                            //unchecked
                                                            args.$form.find('.form-item[rel=cleanup]').hide();
                                                            //hidden
                                                        } else {
                                                            args.$form.find('.form-item[rel=cleanup]').find('input').attr('checked', 'checked');
                                                            //checked
                                                            args.$form.find('.form-item[rel=cleanup]').css('display', 'inline-block');
                                                            //shown
                                                        }
                                                    },
                                                    fields: {
                                                        cleanup: {
                                                            label: 'label.clean.up',
                                                            isBoolean: true
                                                        }
                                                    }
                                                },
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&cleanup=" + (args.data.cleanup == "on"));
                                                    $.ajax({
                                                        url: createURL("restartNetwork&cleanup=true&id=" + args.context.networks[0].id + array1.join("")),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.restartnetworkresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.network;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.restart.network';
                                                    }
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            'remove': {
                                                label: 'label.action.delete.network',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.delete.network';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.delete.network';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("deleteNetwork&id=" + args.context.networks[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.deletenetworkresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return {
                                                                        };
                                                                        //nothing in this network needs to be updated, in fact, this whole template has being deleted
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            }
                                        },
                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                preFilter: function (args) {
                                                    var hiddenFields =[];
                                                    if (selectedZoneObj.networktype == "Basic") {
                                                        hiddenFields.push("account");
                                                        hiddenFields.push("gateway");
                                                        //hiddenFields.push("netmask");
                                                    }

                                                    if (selectedGuestNetworkObj.type == "Isolated") {
                                                        hiddenFields.push("networkofferingdisplaytext");
                                                        hiddenFields.push("networkdomaintext");
                                                        hiddenFields.push("gateway");
                                                        //hiddenFields.push("netmask");
                                                    } else {
                                                        //selectedGuestNetworkObj.type == "Shared"
                                                        hiddenFields.push("networkofferingid");
                                                        hiddenFields.push("networkdomain");
                                                    }
                                                    return hiddenFields;
                                                },
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name',
                                                        isEditable: true
                                                    }
                                                },
                                                {
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    displaytext: {
                                                        label: 'label.description',
                                                        isEditable: true
                                                    },
                                                    type: {
                                                        label: 'label.type'
                                                    },
                                                    state: {
                                                        label: 'label.state'
                                                    },
                                                    restartrequired: {
                                                        label: 'label.restart.required',
                                                        converter: function (booleanValue) {
                                                            if (booleanValue == true)
                                                            return "<font color='red'>Yes</font>"; else if (booleanValue == false)
                                                            return "No";
                                                        }
                                                    },
                                                    vlan: {
                                                        label: 'label.vlan.id'
                                                    },
                                                    broadcasturi: {
                                                        label: 'label.broadcat.uri'
                                                    },
                                                    scope: {
                                                        label: 'label.scope'
                                                    },
                                                    networkofferingdisplaytext: {
                                                        label: 'label.network.offering'
                                                    },
                                                    networkofferingid: {
                                                        label: 'label.network.offering',
                                                        isEditable: true,
                                                        select: function (args) {
                                                            var items =[];
                                                            $.ajax({
                                                                url: createURL("listNetworkOfferings&state=Enabled&networkid=" + selectedGuestNetworkObj.id + "&zoneid=" + selectedGuestNetworkObj.zoneid),
                                                                dataType: "json",
                                                                async: false,
                                                                success: function (json) {
                                                                    var networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering;
                                                                    $(networkOfferingObjs).each(function () {
                                                                        items.push({
                                                                            id: this.id,
                                                                            description: this.displaytext
                                                                        });
                                                                    });
                                                                }
                                                            });

                                                            //include currently selected network offeirng to dropdown
                                                            items.push({
                                                                id: selectedGuestNetworkObj.networkofferingid,
                                                                description: selectedGuestNetworkObj.networkofferingdisplaytext
                                                            });

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

                                                    networkofferingidText: {
                                                        label: 'label.network.offering.id'
                                                    },

                                                    gateway: {
                                                        label: 'label.ipv4.gateway'
                                                    },
                                                    //netmask: { label: 'label.netmask' },
                                                    cidr: {
                                                        label: 'label.ipv4.cidr'
                                                    },

                                                    ip6gateway: {
                                                        label: 'label.ipv6.gateway'
                                                    },
                                                    ip6cidr: {
                                                        label: 'label.ipv6.CIDR'
                                                    },

                                                    networkdomaintext: {
                                                        label: 'label.network.domain'
                                                    },
                                                    networkdomain: {
                                                        label: 'label.network.domain',
                                                        isEditable: true
                                                    },

                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    subdomainaccess: {
                                                        label: 'label.subdomain.access',
                                                        converter: function (data) {
                                                            return data ? 'Yes': 'No';
                                                        }
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    project: {
                                                        label: 'label.project'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    var data = {
                                                        id: args.context.networks[0].id
                                                    };
                                                    if (args.context.networks[0].projectid != null) {
                                                        $.extend(data, {
                                                            projectid: -1
                                                        });
                                                    } else {
                                                        $.extend(data, {
                                                            listAll: true //pass "&listAll=true" to "listNetworks&id=xxxxxxxx" for now before API gets fixed.
                                                        });
                                                    }

                                                    $.ajax({
                                                        url: createURL("listNetworks"),
                                                        data: data,
                                                        async: false,
                                                        success: function (json) {
                                                            selectedGuestNetworkObj = json.listnetworksresponse.network[0];
                                                            addExtraPropertiesToGuestNetworkObject(selectedGuestNetworkObj);

                                                            $(window).trigger('cloudStack.module.sharedFunctions.addExtraProperties', {
                                                                obj: selectedGuestNetworkObj,
                                                                objType: "Network"
                                                            });

                                                            args.response.success({
                                                                actionFilter: cloudStack.actionFilter.guestNetwork,
                                                                data: selectedGuestNetworkObj
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            },

                            dedicatedGuestVlanRanges: {
                                title: 'label.dedicated.vlan.vni.ranges',
                                listView: {
                                    section: 'dedicatedGuestVlanRanges',
                                    id: 'dedicatedGuestVlanRanges',
                                    fields: {
                                        guestvlanrange: {
                                            label: 'label.vlan.vni.ranges'
                                        },
                                        domain: {
                                            label: 'label.domain'
                                        },
                                        account: {
                                            label: 'label.account'
                                        }
                                    },
                                    dataProvider: function (args) {
                                        $.ajax({
                                            url: createURL('listDedicatedGuestVlanRanges'),
                                            data: {
                                                physicalnetworkid: args.context.physicalNetworks[0].id
                                            },
                                            success: function (json) {
                                                var items = json.listdedicatedguestvlanrangesresponse.dedicatedguestvlanrange;
                                                args.response.success({
                                                    data: items
                                                })
                                            }
                                        });
                                    },
                                    actions: {
                                        add: {
                                            label: 'label.dedicate.vlan.vni.range',
                                            messages: {
                                                notification: function (args) {
                                                    return 'label.dedicate.vlan.vni.range';
                                                }
                                            },
                                            createForm: {
                                                title: 'label.dedicate.vlan.vni.range',
                                                fields: {
                                                    vlanrange: {
                                                        label: 'label.vlan.vni.range',
                                                        validation: {
                                                            required: true
                                                        }
                                                    },
                                                    scope: {
                                                        label: 'label.scope',
                                                        docID: 'helpGuestNetworkZoneScope',
                                                        select: function(args) {
                                                            var array1 = [];

                                                            array1.push({
                                                                id: 'account-specific',
                                                                description: 'label.account'
                                                            });
                                                            array1.push({
                                                                id: 'project-specific',
                                                                description: 'label.project'
                                                            });

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

                                                            args.$select.change(function() {
                                                                var $form = $(this).closest('form');

                                                                if ($(this).val() == "account-specific") {
                                                                    $form.find('.form-item[rel=domainId]').css('display', 'inline-block');
                                                                    $form.find('.form-item[rel=account]').css('display', 'inline-block');
                                                                    $form.find('.form-item[rel=projectId]').hide();
                                                                } else if ($(this).val() == "project-specific") {
                                                                    $form.find('.form-item[rel=domainId]').css('display', 'inline-block');
                                                                    $form.find('.form-item[rel=account]').hide();
                                                                    $form.find('.form-item[rel=projectId]').css('display', 'inline-block');
                                                                }

                                                                if (args.context.projects != null && args.context.projects.length > 0) {
                                                                    $form.find('.form-item[rel=domainId]').hide();
                                                                    $form.find('.form-item[rel=account]').hide();
                                                                    $form.find('.form-item[rel=projectId]').hide();
                                                                }
                                                            });
                                                        },
                                                        isHidden: function(args) {
                                                            if(args.context.projects != null && args.context.projects.length > 0)
                                                                return true;
                                                            else
                                                                return false;
                                                        }
                                                    },
                                                    domainId: {
                                                        label: 'label.domain',
                                                        validation: {
                                                            required: true
                                                        },
                                                        select: function (args) {
                                                            $.ajax({
                                                                url: createURL('listDomains'),
                                                                data: {
                                                                    details: 'min',
                                                                    listAll: true
                                                                },
                                                                success: function (json) {
                                                                    args.response.success({
                                                                        data: $.map(json.listdomainsresponse.domain, function (domain) {
                                                                            return {
                                                                                id: domain.id,
                                                                                description: domain.path
                                                                            };
                                                                        })
                                                                    });
                                                                }
                                                            });
                                                        }
                                                    },
                                                    account: {
                                                        label: 'label.account',
                                                        validation: {
                                                            required: true
                                                        },
                                                        dependsOn: 'domainId',
                                                        select: function (args) {
                                                            $.ajax({
                                                                url: createURL('listAccounts&domainid=' + args.domainId),
                                                                data: {
                                                                    details: 'min',
                                                                    listAll: true
                                                                },
                                                                success: function (json) {
                                                                    args.response.success({
                                                                        data: $.map(json.listaccountsresponse.account, function (account) {
                                                                            return {
                                                                                id: account.name,
                                                                                description: account.name
                                                                            };
                                                                        })
                                                                    });
                                                                }
                                                            });
                                                        }
                                                    },
                                                    projectId: {
                                                        label: 'label.project',
                                                        validation: {
                                                            required: true
                                                        },
                                                        dependsOn: 'domainId',
                                                        select: function(args) {
                                                            var items = [];
                                                            $.ajax({
                                                                url: createURL("listProjects&details=min&domainid=" + args.domainId),
                                                                dataType: "json",
                                                                async: false,
                                                                success: function(json) {
                                                                    projectObjs = json.listprojectsresponse.project;
                                                                    $(projectObjs).each(function() {
                                                                        items.push({
                                                                            id: this.id,
                                                                            description: this.name
                                                                        });
                                                                    });
                                                                }
                                                            });
                                                            args.response.success({
                                                                data: items
                                                            });
                                                        }
                                                    }
                                                }
                                            },
                                            action: function (args) {
                                                var data = {
                                                    physicalnetworkid: args.context.physicalNetworks[0].id,
                                                    vlanrange: args.data.vlanrange
                                                };

                                                var $form = args.$form;

                                                if (($form.find('.form-item[rel=domainId]').css("display") != "none") && (args.data.domainId != null && args.data.domainId.length > 0)) {
                                                    $.extend(data, {
                                                        domainid: args.data.domainId
                                                    })
                                                }

                                                if (($form.find('.form-item[rel=account]').css("display") != "none") && (args.data.account != null && args.data.account.length > 0)) {
                                                    $.extend(data, {
                                                        account: args.data.account
                                                    })
                                                }

                                                if (($form.find('.form-item[rel=projectId]').css("display") != "none") && (args.data.projectId != null && args.data.projectId.length > 0)) {
                                                    $.extend(data, {
                                                        projectid: args.data.projectId
                                                    })
                                                }

                                                $.ajax({
                                                    url: createURL('dedicateGuestVlanRange'),
                                                    data: data,
                                                    success: function (json) {
                                                        var item = json.dedicateguestvlanrangeresponse.dedicatedguestvlanrange;
                                                        args.response.success({
                                                            data: item
                                                        });
                                                    }
                                                });
                                            },
                                            notification: {
                                                poll: function (args) {
                                                    args.complete();
                                                }
                                            }
                                        }
                                    },

                                    detailView: {
                                        name: 'label.vlan.range.details',
                                        actions: {
                                            remove: {
                                                label: 'label.release.dedicated.vlan.range',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.confirm.release.dedicate.vlan.range';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.release.dedicated.vlan.range';
                                                    }
                                                },
                                                action: function (args) {
                                                    var data = {
                                                        id: args.context.dedicatedGuestVlanRanges[0].id
                                                    };
                                                    $.ajax({
                                                        url: createURL('releaseDedicatedGuestVlanRange'),
                                                        data: data,
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.releasededicatedguestvlanrangeresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            }
                                        },

                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                fields:[ {
                                                    guestvlanrange: {
                                                        label: 'label.vlan.ranges'
                                                    }
                                                },
                                                {
                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    id: {
                                                        label: 'label.id'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL('listDedicatedGuestVlanRanges'),
                                                        data: {
                                                            id: args.context.dedicatedGuestVlanRanges[0].id
                                                        },
                                                        success: function (json) {
                                                            var item = json.listdedicatedguestvlanrangesresponse.dedicatedguestvlanrange[0];
                                                            args.response.success({
                                                                data: item
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            },

            networks: {
                listView: {
                    id: 'physicalNetworks',
                    hideToolbar: true,
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        state: {
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            label: 'label.state',
                            indicator: {
                                'Enabled': 'on',
                                'Disabled': 'off'
                            }
                        },
                        isolationmethods: {
                            label: 'label.isolation.method'
                        },
                        vlan: {
                            label: 'label.vlan'
                        },
                        broadcastdomainrange: {
                            label: 'label.broadcast.domain.range'
                        }
                    },

                    actions: {
                        remove: {
                            label: 'label.action.delete.physical.network',
                            messages: {
                                confirm: function (args) {
                                    return 'message.action.delete.physical.network';
                                },
                                notification: function (args) {
                                    return 'label.action.delete.physical.network';
                                }
                            },
                            action: function (args) {
                                $.ajax({
                                    url: createURL("deletePhysicalNetwork&id=" + args.context.physicalNetworks[0].id),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        var jid = json.deletephysicalnetworkresponse.jobid;
                                        args.response.success({
                                            _custom: {
                                                jobId: jid
                                            }
                                        });
                                    }
                                });
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    }
                },
                dataProvider: function (args) {
                    $.ajax({
                        url: createURL('listPhysicalNetworks'),
                        data: {
                            zoneid: args.context.zones[0].id
                        },
                        success: function (json) {
                            physicalNetworkObjs = json.listphysicalnetworksresponse.physicalnetwork;
                            args.response.success({
                                actionFilter: cloudStack.actionFilter.physicalNetwork,
                                data: json.listphysicalnetworksresponse.physicalnetwork
                            });
                        }
                    });
                }
            },

            trafficTypes: {
                dataProvider: function (args) {
                    selectedPhysicalNetworkObj = args.context.physicalNetworks[0];

                    $.ajax({
                        url: createURL('listTrafficTypes'),
                        data: {
                            physicalnetworkid: selectedPhysicalNetworkObj.id
                        },
                        success: function (json) {
                            args.response.success({
                                data: $.map(json.listtraffictypesresponse.traffictype, function (trafficType) {
                                    return {
                                        id: trafficType.id,
                                        name: trafficType.traffictype
                                    };
                                })
                            });
                        }
                    });
                }
            },

            networkProviders: {
                statusLabels: {
                    enabled: 'Enabled', //having device, network service provider is enabled
                    'not-configured': 'Not setup', //no device
                    disabled: 'Disabled' //having device, network service provider is disabled
                },

                // Actions performed on entire net. provider type
                actions: {
                    enable: function (args) {
                        args.response.success();
                    },

                    disable: function (args) {
                        args.response.success();
                    }
                },

                types: {
                    virtualRouter: {
                        id: 'virtualRouterProviders',
                        label: 'label.virtual.router',
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            ipaddress: {
                                label: 'label.ip.address'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    },
                                    destinationphysicalnetworkid: {
                                        label: 'label.destination.physical.network.id'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("VirtualRouter");
                                    args.response.success({
                                        actionFilter: virtualRouterProviderActionFilter,
                                        data: $.extend(nspMap[ "virtualRouter"], {
                                            supportedServices: nspMap[ "virtualRouter"].servicelist.join(', ')
                                        })
                                    });
                                }
                            },

                            instances: {
                                title: 'label.instances',
                                listView: {
                                    label: 'label.virtual.appliances',
                                    id: 'routers',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        zonename: {
                                            label: 'label.zone'
                                        },
                                        routerType: {
                                            label: 'label.type'
                                        },
                                        state: {
                                            converter: function (str) {
                                                // For localization
                                                return str;
                                            },
                                            label: 'label.status',
                                            indicator: {
                                                'Running': 'on',
                                                'Stopped': 'off',
                                                'Error': 'off'
                                            }
                                        }
                                    },
                                    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;
                                                }
                                            }
                                        }

                                        var data2 = {
                                            forvpc: false
                                        };
                                        var routers =[];
                                        $.ajax({
                                            url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            data: data2,
                                            success: function (json) {
                                                var items = json.listroutersresponse.router ?
                                                json.listroutersresponse.router:[];

                                                $(items).map(function (index, item) {
                                                    routers.push(item);
                                                });

                                                /*
                                                 * In project view, the first listRotuers API(without projectid=-1) will return the same objects as the second listRouters API(with projectid=-1),
                                                 * because in project view, all API calls are appended with projectid=[projectID].
                                                 * Therefore, we only call the second listRouters API(with projectid=-1) in non-project view.
                                                 */
                                                if (cloudStack.context && cloudStack.context.projects == null) { //non-project view
                                                $.ajax({
                                                    url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("") + "&projectid=-1"),
                                                    data: data2,
                                                        async: false,
                                                    success: function (json) {
                                                        var items = json.listroutersresponse.router ?
                                                        json.listroutersresponse.router:[];

                                                        $(items).map(function (index, item) {
                                                            routers.push(item);
                                                        });
                                                        }
                                                    });
                                                }

                                                        args.response.success({
                                                            actionFilter: routerActionfilter,
                                                            data: $(routers).map(mapRouterType)
                                                        });
                                                    }
                                                });
                                    },
                                    detailView: {
                                        name: 'label.virtual.appliance.details',
                                        actions: {
                                            start: {
                                                label: 'label.action.start.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.start.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.start.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('startRouter&id=' + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.startrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.router;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            stop: {
                                                label: 'label.action.stop.router',
                                                createForm: {
                                                    title: 'label.action.stop.router',
                                                    desc: 'message.action.stop.router',
                                                    fields: {
                                                        forced: {
                                                            label: 'force.stop',
                                                            isBoolean: true,
                                                            isChecked: false
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.stop.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&forced=" + (args.data.forced == "on"));
                                                    $.ajax({
                                                        url: createURL('stopRouter&id=' + args.context.routers[0].id + array1.join("")),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.stoprouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.router;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            'remove': {
                                                label: 'label.destroy.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        if (args && args.context && args.context.routers[0]) {
                                                            if (args.context.routers[0].state == 'Running') {
                                                                return dictionary['message.action.stop.router'] + ' ' + dictionary['message.confirm.destroy.router'];
                                                            }
                                                        }
                                                        return 'message.confirm.destroy.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.destroy.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("destroyRouter&id=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.destroyrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            migrate: {
                                                label: 'label.action.migrate.router',
                                                createForm: {
                                                    title: 'label.action.migrate.router',
                                                    desc: '',
                                                    fields: {
                                                        hostId: {
                                                            label: 'label.host',
                                                            validation: {
                                                                required: true
                                                            },
                                                            select: function (args) {
                                                                $.ajax({
                                                                    url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.routers[0].id),
                                                                    dataType: "json",
                                                                    async: true,
                                                                    success: function (json) {
                                                                        var hostObjs = json.findhostsformigrationresponse.host;
                                                                        var items =[];
                                                                        $(hostObjs).each(function () {
                                                                            items.push({
                                                                                id: this.id,
                                                                                description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                            });
                                                                        });
                                                                        args.response.success({
                                                                            data: items
                                                                        });
                                                                    }
                                                                });
                                                            },
                                                            error: function (XMLHttpResponse) {
                                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                args.response.error(errorMsg);
                                                            }
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.migrate.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.migratesystemvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                        $.ajax({
                                                                            url: createURL("listRouters&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                            dataType: "json",
                                                                            async: false,
                                                                            success: function (json) {
                                                                                var items = json.listroutersresponse.router;
                                                                                if (items != null && items.length > 0) {
                                                                                    return items[0];
                                                                                }
                                                                            }
                                                                        });
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            viewConsole: {
                                                label: 'label.view.console',
                                                action: {
                                                    externalLink: {
                                                        url: function (args) {
                                                            return clientConsoleUrl + '?cmd=access&vm=' + args.context.routers[0].id;
                                                        },
                                                        title: function (args) {
                                                            return args.context.routers[0].id.substr(0, 8);
                                                            //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                        },
                                                        width: 820,
                                                        height: 640
                                                    }
                                                }
                                            }
                                        },
                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                preFilter: function (args) {
                                                    var hiddenFields =[];
                                                    if (! args.context.routers[0].project) {
                                                        hiddenFields.push('project');
                                                        hiddenFields.push('projectid');
                                                    }
                                                    if (selectedZoneObj.networktype == 'Basic') {
                                                        hiddenFields.push('publicip');
                                                        //In Basic zone, guest IP is public IP. So, publicip is not returned by listRouters API. Only guestipaddress is returned by listRouters API.
                                                    }

                                                    if ('routers' in args.context && args.context.routers[0].vpcid != undefined) {
                                                        hiddenFields.push('guestnetworkid');
                                                        hiddenFields.push('guestnetworkname');
                                                    } else if ('routers' in args.context && args.context.routers[0].guestnetworkid != undefined) {
                                                        hiddenFields.push('vpcid');
                                                        hiddenFields.push('vpcname');
                                                    }

                                                    return hiddenFields;
                                                },
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name'
                                                    },
                                                    project: {
                                                        label: 'label.project'
                                                    }
                                                },
                                                {
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    projectid: {
                                                        label: 'label.project.id'
                                                    },
                                                    state: {
                                                        label: 'label.state'
                                                    },
                                                    guestnetworkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    guestnetworkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    vpcid: {
                                                        label: 'label.vpc.id'
                                                    },
                                                    vpcname: {
                                                        label: 'label.vpc'
                                                    },
                                                    publicip: {
                                                        label: 'label.public.ip'
                                                    },
                                                    guestipaddress: {
                                                        label: 'label.guest.ip'
                                                    },
                                                    linklocalip: {
                                                        label: 'label.linklocal.ip'
                                                    },
                                                    hostname: {
                                                        label: 'label.host'
                                                    },
                                                    serviceofferingname: {
                                                        label: 'label.compute.offering'
                                                    },
                                                    networkdomain: {
                                                        label: 'label.network.domain'
                                                    },
                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    created: {
                                                        label: 'label.created',
                                                        converter: cloudStack.converters.toLocalDate
                                                    },
                                                    isredundantrouter: {
                                                        label: 'label.redundant.router',
                                                        converter: cloudStack.converters.toBooleanText
                                                    },
                                                    redundantRouterState: {
                                                        label: 'label.redundant.state'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listroutersresponse.router[0];
                                                            addExtraPropertiesToRouterInstanceObject(jsonObj);
                                                            args.response.success({
                                                                actionFilter: routerActionfilter,
                                                                data: jsonObj
                                                            });
                                                        }
                                                    });
                                                }
                                            },
                                            nics: {
                                                title: 'label.nics',
                                                multiple: true,
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name',
                                                        header: true
                                                    },
                                                    type: {
                                                        label: 'label.type'
                                                    },
                                                    traffictype: {
                                                        label: 'label.traffic.type'
                                                    },
                                                    networkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    netmask: {
                                                        label: 'label.netmask'
                                                    },
                                                    ipaddress: {
                                                        label: 'label.ip.address'
                                                    },
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    networkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    isolationuri: {
                                                        label: 'label.isolation.uri'
                                                    },
                                                    broadcasturi: {
                                                        label: 'label.broadcast.uri'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listroutersresponse.router[0].nic;

                                                            args.response.success({
                                                                actionFilter: routerActionfilter,
                                                                data: $.map(jsonObj, function (nic, index) {
                                                                    var name = 'NIC ' + (index + 1);
                                                                    if (nic.isdefault) {
                                                                        name += ' (' + _l('label.default') + ')';
                                                                    }
                                                                    return $.extend(nic, {
                                                                        name: name
                                                                    });
                                                                })
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "virtualRouter"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "virtualRouter"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    InternalLbVm: {
                        id: 'InternalLbVm',
                        label: 'label.internallbvm',
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            ipaddress: {
                                label: 'label.ip.address'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    },
                                    destinationphysicalnetworkid: {
                                        label: 'label.destination.physical.network.id'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("InternalLbVm");
                                    args.response.success({
                                        actionFilter: virtualRouterProviderActionFilter,
                                        data: $.extend(nspMap[ "InternalLbVm"], {
                                            supportedServices: nspMap[ "InternalLbVm"].servicelist.join(', ')
                                        })
                                    });
                                }
                            },

                            instances: {
                                title: 'label.instances',
                                listView: {
                                    label: 'label.virtual.appliances',
                                    id: 'internallbinstances',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        zonename: {
                                            label: 'label.zone'
                                        },
                                        routerType: {
                                            label: 'label.type'
                                        },
                                        state: {
                                            converter: function (str) {
                                                // For localization
                                                return str;
                                            },
                                            label: 'label.status',
                                            indicator: {
                                                'Running': 'on',
                                                'Stopped': 'off',
                                                'Error': 'off'
                                            }
                                        }
                                    },
                                    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;
                                                }
                                            }
                                        }

                                        var routers =[];
                                        $.ajax({
                                            url: createURL("listInternalLoadBalancerVMs&zoneid=" + selectedZoneObj.id + "&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            success: function (json) {
                                                var items = json.listinternallbvmsresponse.internalloadbalancervm ?
                                                json.listinternallbvmsresponse.internalloadbalancervm:[];

                                                $(items).map(function (index, item) {
                                                    routers.push(item);
                                                });

                                                // Get project routers
                                                $.ajax({
                                                    url: createURL("listInternalLoadBalancerVMs&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("") + "&projectid=-1"),
                                                    success: function (json) {
                                                        var items = json.listinternallbvmsresponse.internalloadbalancervm ?
                                                        json.listinternallbvmsresponse.internalloadbalancervm:[];

                                                        $(items).map(function (index, item) {
                                                            routers.push(item);
                                                        });
                                                        args.response.success({
                                                            actionFilter: internallbinstanceActionfilter,
                                                            data: $(routers).map(mapRouterType)
                                                        });
                                                    }
                                                });
                                            }
                                        });
                                    },
                                    detailView: {
                                        name: 'label.virtual.appliance.details',
                                        actions: {
                                            start: {
                                                label: 'label.start.lb.vm',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.confirm.start.lb.vm';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.start.lb.vm';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('startInternalLoadBalancerVM&id=' + args.context.internallbinstances[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.startinternallbvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.internalloadbalancervm;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return internallbinstanceActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            stop: {
                                                label: 'label.stop.lb.vm',
                                                createForm: {
                                                    title: 'message.confirm.stop.lb.vm',
                                                    desc: 'label.stop.lb.vm',
                                                    fields: {
                                                        forced: {
                                                            label: 'force.stop',
                                                            isBoolean: true,
                                                            isChecked: false
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.stop.lb.vm';
                                                    }
                                                },
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&forced=" + (args.data.forced == "on"));
                                                    $.ajax({
                                                        url: createURL('stopInternalLoadBalancerVM&id=' + args.context.internallbinstances[0].id + array1.join("")),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.stopinternallbvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.internalloadbalancervm;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return internallbinstanceActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            migrate: {
                                                label: 'label.migrate.lb.vm',
                                                createForm: {
                                                    title: 'label.migrate.lb.vm',
                                                    fields: {
                                                        hostId: {
                                                            label: 'label.host',
                                                            validation: {
                                                                required: true
                                                            },
                                                            select: function (args) {
                                                                $.ajax({
                                                                    url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.internallbinstances[0].id),
                                                                    dataType: "json",
                                                                    async: true,
                                                                    success: function (json) {
                                                                        var hostObjs = json.findhostsformigrationresponse.host;
                                                                        var items =[];
                                                                        $(hostObjs).each(function () {
                                                                            items.push({
                                                                                id: this.id,
                                                                                description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                            });
                                                                        });
                                                                        args.response.success({
                                                                            data: items
                                                                        });
                                                                    }
                                                                });
                                                            },
                                                            error: function (XMLHttpResponse) {
                                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                args.response.error(errorMsg);
                                                            }
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.migrate.lb.vm';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.internallbinstances[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.migratesystemvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                        $.ajax({
                                                                            url: createURL("listInternalLoadBalancerVMs&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                            dataType: "json",
                                                                            async: false,
                                                                            success: function (json) {
                                                                                var items = json.listinternallbvmsresponse.internalloadbalancervm;
                                                                                if (items != null && items.length > 0) {
                                                                                    return items[0];
                                                                                }
                                                                            }
                                                                        });
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return internallbinstanceActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            viewConsole: {
                                                label: 'label.view.console',
                                                action: {
                                                    externalLink: {
                                                        url: function (args) {
                                                            return clientConsoleUrl + '?cmd=access&vm=' + args.context.internallbinstances[0].id;
                                                        },
                                                        title: function (args) {
                                                            return args.context.internallbinstances[0].id.substr(0, 8);
                                                            //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                        },
                                                        width: 820,
                                                        height: 640
                                                    }
                                                }
                                            }
                                        },
                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                preFilter: function (args) {
                                                    var hiddenFields =[];
                                                    if (! args.context.internallbinstances[0].project) {
                                                        hiddenFields.push('project');
                                                        hiddenFields.push('projectid');
                                                    }
                                                    if (selectedZoneObj.networktype == 'Basic') {
                                                        hiddenFields.push('publicip');
                                                        //In Basic zone, guest IP is public IP. So, publicip is not returned by listRouters API. Only guestipaddress is returned by listRouters API.
                                                    }

                                                    if ('routers' in args.context && args.context.routers[0].vpcid != undefined) {
                                                        hiddenFields.push('guestnetworkid');
                                                        hiddenFields.push('guestnetworkname');
                                                    } else if ('routers' in args.context && args.context.routers[0].guestnetworkid != undefined) {
                                                        hiddenFields.push('vpcid');
                                                        hiddenFields.push('vpcname');
                                                    }

                                                    return hiddenFields;
                                                },
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name'
                                                    },
                                                    project: {
                                                        label: 'label.project'
                                                    }
                                                },
                                                {
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    projectid: {
                                                        label: 'label.project.id'
                                                    },
                                                    state: {
                                                        label: 'label.state'
                                                    },
                                                    guestnetworkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    guestnetworkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    vpcid: {
                                                        label: 'label.vpc.id'
                                                    },
                                                    vpcname: {
                                                        label: 'label.vpc'
                                                    },
                                                    publicip: {
                                                        label: 'label.public.ip'
                                                    },
                                                    guestipaddress: {
                                                        label: 'label.guest.ip'
                                                    },
                                                    linklocalip: {
                                                        label: 'label.linklocal.ip'
                                                    },
                                                    hostname: {
                                                        label: 'label.host'
                                                    },
                                                    serviceofferingname: {
                                                        label: 'label.compute.offering'
                                                    },
                                                    networkdomain: {
                                                        label: 'label.network.domain'
                                                    },
                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    created: {
                                                        label: 'label.created',
                                                        converter: cloudStack.converters.toLocalDate
                                                    },
                                                    isredundantrouter: {
                                                        label: 'label.redundant.router',
                                                        converter: cloudStack.converters.toBooleanText
                                                    },
                                                    redundantRouterState: {
                                                        label: 'label.redundant.state'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listInternalLoadBalancerVMs&id=" + args.context.internallbinstances[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listinternallbvmsresponse.internalloadbalancervm[0];
                                                            addExtraPropertiesToRouterInstanceObject(jsonObj);
                                                            args.response.success({
                                                                actionFilter: internallbinstanceActionfilter,
                                                                data: jsonObj
                                                            });
                                                        }
                                                    });
                                                }
                                            },
                                            nics: {
                                                title: 'label.nics',
                                                multiple: true,
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name',
                                                        header: true
                                                    },
                                                    type: {
                                                        label: 'label.type'
                                                    },
                                                    traffictype: {
                                                        label: 'label.traffic.type'
                                                    },
                                                    networkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    netmask: {
                                                        label: 'label.netmask'
                                                    },
                                                    ipaddress: {
                                                        label: 'label.ip.address'
                                                    },
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    networkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    isolationuri: {
                                                        label: 'label.isolation.uri'
                                                    },
                                                    broadcasturi: {
                                                        label: 'label.broadcast.uri'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listInternalLoadBalancerVMs&id=" + args.context.internallbinstances[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listinternallbvmsresponse.internalloadbalancervm[0].nic;

                                                            args.response.success({
                                                                actionFilter: internallbinstanceActionfilter,
                                                                data: $.map(jsonObj, function (nic, index) {
                                                                    var name = 'NIC ' + (index + 1);
                                                                    if (nic.isdefault) {
                                                                        name += ' (' + _l('label.default') + ')';
                                                                    }
                                                                    return $.extend(nic, {
                                                                        name: name
                                                                    });
                                                                })
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "InternalLbVm"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "InternalLbVm"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    vpcVirtualRouter: {
                        id: 'vpcVirtualRouterProviders',
                        label: 'label.vpc.virtual.router',
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            ipaddress: {
                                label: 'label.ip.address'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    },
                                    destinationphysicalnetworkid: {
                                        label: 'label.destination.physical.network.id'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("VpcVirtualRouter");
                                    args.response.success({
                                        actionFilter: virtualRouterProviderActionFilter,
                                        data: $.extend(nspMap[ "vpcVirtualRouter"], {
                                            supportedServices: nspMap[ "vpcVirtualRouter"].servicelist.join(', ')
                                        })
                                    });
                                }
                            },

                            instances: {
                                title: 'label.instances',
                                listView: {
                                    label: 'label.virtual.appliances',
                                    id: 'routers',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        zonename: {
                                            label: 'label.zone'
                                        },
                                        routerType: {
                                            label: 'label.type'
                                        },
                                        state: {
                                            converter: function (str) {
                                                // For localization
                                                return str;
                                            },
                                            label: 'label.status',
                                            indicator: {
                                                'Running': 'on',
                                                'Stopped': 'off',
                                                'Error': 'off'
                                            }
                                        }
                                    },
                                    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;
                                                }
                                            }
                                        }

                                        var data2 = {
                                            forvpc: true
                                        };
                                        var routers =[];
                                        $.ajax({
                                            url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            dataType: 'json',
                                            data: data2,
                                            async: true,
                                            success: function (json) {
                                                var items = json.listroutersresponse.router;
                                                $(items).map(function (index, item) {
                                                    routers.push(item);
                                                });

                                                /*
                                                 * In project view, the first listRotuers API(without projectid=-1) will return the same objects as the second listRouters API(with projectid=-1),
                                                 * because in project view, all API calls are appended with projectid=[projectID].
                                                 * Therefore, we only call the second listRouters API(with projectid=-1) in non-project view.
                                                 */
                                                if (cloudStack.context && cloudStack.context.projects == null) { //non-project view
                                                $.ajax({
                                                    url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("") + "&projectid=-1"),
                                                    dataType: 'json',
                                                    data: data2,
                                                        async: false,
                                                    success: function (json) {
                                                        var items = json.listroutersresponse.router;
                                                        $(items).map(function (index, item) {
                                                            routers.push(item);
                                                        });
                                                        }
                                                    });
                                                }

                                                        args.response.success({
                                                            actionFilter: routerActionfilter,
                                                            data: $(routers).map(mapRouterType)
                                                        });
                                                    }
                                                });
                                    },
                                    detailView: {
                                        name: 'label.virtual.appliance.details',
                                        actions: {
                                            start: {
                                                label: 'label.action.start.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.start.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.start.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('startRouter&id=' + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.startrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.router;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            stop: {
                                                label: 'label.action.stop.router',
                                                createForm: {
                                                    title: 'label.action.stop.router',
                                                    desc: 'message.action.stop.router',
                                                    fields: {
                                                        forced: {
                                                            label: 'force.stop',
                                                            isBoolean: true,
                                                            isChecked: false
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.stop.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&forced=" + (args.data.forced == "on"));
                                                    $.ajax({
                                                        url: createURL('stopRouter&id=' + args.context.routers[0].id + array1.join("")),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.stoprouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.router;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            restart: {
                                                label: 'label.action.reboot.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.reboot.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.reboot.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('rebootRouter&id=' + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.rebootrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.router;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            'remove': {
                                                label: 'label.destroy.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        if (args && args.context && args.context.routers[0]) {
                                                            if (args.context.routers[0].state == 'Running') {
                                                                return dictionary['message.action.stop.router'] + ' ' + dictionary['message.confirm.destroy.router'];
                                                            }
                                                        }
                                                        return 'message.confirm.destroy.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.destroy.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("destroyRouter&id=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.destroyrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            migrate: {
                                                label: 'label.action.migrate.router',
                                                createForm: {
                                                    title: 'label.action.migrate.router',
                                                    desc: '',
                                                    fields: {
                                                        hostId: {
                                                            label: 'label.host',
                                                            validation: {
                                                                required: true
                                                            },
                                                            select: function (args) {
                                                                $.ajax({
                                                                    url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.routers[0].id),
                                                                    dataType: "json",
                                                                    async: true,
                                                                    success: function (json) {
                                                                        var hostObjs = json.findhostsformigrationresponse.host;
                                                                        var items =[];
                                                                        $(hostObjs).each(function () {
                                                                            items.push({
                                                                                id: this.id,
                                                                                description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                            });
                                                                        });
                                                                        args.response.success({
                                                                            data: items
                                                                        });
                                                                    }
                                                                });
                                                            },
                                                            error: function (XMLHttpResponse) {
                                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                args.response.error(errorMsg);
                                                            }
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.migrate.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.migratesystemvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                        $.ajax({
                                                                            url: createURL("listRouters&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                            dataType: "json",
                                                                            async: false,
                                                                            success: function (json) {
                                                                                var items = json.listroutersresponse.router;
                                                                                if (items != null && items.length > 0) {
                                                                                    return items[0];
                                                                                }
                                                                            }
                                                                        });
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            diagnostics: {
                                                label: 'label.action.run.diagnostics',
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.run.diagnostics';
                                                    },
                                                    complete: function(args) {
                                                        var exitcode = _l('message.diagnostics.exitcode');
                                                        exitcode = exitcode.replace('var', args.exitcode);
                                                        var stderr = _l('message.diagnostics.stderr');
                                                        stderr = stderr.replace('var', args.stderr);
                                                        var stdout = _l('message.diagnostics.stdout');
                                                        stdout = stdout.replace('var', args.stdout);
                                                        var msg = "<div style='text-align: left; overflow-y: auto'>" + exitcode + "<br><br>" + stderr + "<br><br>" + stdout + "</div>";
                                                        return msg;
                                                    }
                                                },
                                                createForm: {
                                                    title: 'label.action.run.diagnostics',
                                                    desc: '',
                                                    fields: {
                                                        type: {
                                                            label: 'label.run.diagnostics.type',
                                                            validation: {
                                                                required: true
                                                            },
                                                            select: function (args) {
                                                                var items = [];
                                                                items.push({
                                                                    id: "ping",
                                                                    description: "Ping"
                                                                });
                                                                items.push({
                                                                    id: "traceroute",
                                                                    description: "Traceroute"
                                                                });
                                                                items.push({
                                                                    id: "arping",
                                                                    description: "Arping"
                                                                });
                                                                args.response.success({
                                                                    data: items
                                                                });
                                                            }
                                                        },
                                                        destination: {
                                                            label: 'label.run.diagnostics.destination',
                                                            validation: {
                                                                required: true
                                                            }
                                                        },
                                                        extra: {
                                                            label: 'label.run.diagnostics.extra'
                                                        }

                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("runDiagnostics&targetid=" + args.context.systemVMs[0].id + "&ipaddress=" + args.data.destination + "&type=" + args.data.type + "&params=" + args.data.extra),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function(json) {
                                                            var jid = json.rundiagnosticsresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId : jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                                    },
                                                                    getActionFilter: function(){
                                                                        return systemvmActionfilter;
                                                                   }
                                                                }

                                                            });
                                                        }
                                                    }); //end ajax
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            retrieveDiagnostics: {
                                                label: 'label.action.get.diagnostics',
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.get.diagnostics';
                                                    },
                                                    complete: function(args) {
                                                        var url = args.url;
                                                        var htmlMsg = _l('message.download.diagnostics');
                                                        var htmlMsg2 = htmlMsg.replace(/#/, url).replace(/00000/, url);
                                                        return htmlMsg2;
                                                    }
                                                },
                                                createForm: {
                                                    title: 'label.action.get.diagnostics',
                                                    desc: 'label.get.diagnostics.desc',
                                                    fields: {
                                                        files: {
                                                            label: 'label.get.diagnostics.files'
                                                        }
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("getDiagnosticsData&targetid=" + args.context.routers[0].id + "&files=" + args.data.files),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function(json) {
                                                            var jid = json.getdiagnosticsdataresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId : jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                                    },
                                                                    getActionFilter: function(){
                                                                        return systemvmActionfilter;
                                                                   }
                                                                }

                                                            });
                                                        }
                                                    }); //end ajax
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            viewConsole: {
                                                label: 'label.view.console',
                                                action: {
                                                    externalLink: {
                                                        url: function (args) {
                                                            return clientConsoleUrl + '?cmd=access&vm=' + args.context.routers[0].id;
                                                        },
                                                        title: function (args) {
                                                            return args.context.routers[0].id.substr(0, 8);
                                                            //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                        },
                                                        width: 820,
                                                        height: 640
                                                    }
                                                }
                                            }
                                        },
                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                preFilter: function (args) {
                                                    var hiddenFields =[];
                                                    if (! args.context.routers[0].project) {
                                                        hiddenFields.push('project');
                                                        hiddenFields.push('projectid');
                                                    }
                                                    if (selectedZoneObj.networktype == 'Basic') {
                                                        hiddenFields.push('publicip');
                                                        //In Basic zone, guest IP is public IP. So, publicip is not returned by listRouters API. Only guestipaddress is returned by listRouters API.
                                                    }
                                                    return hiddenFields;
                                                },
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name'
                                                    },
                                                    project: {
                                                        label: 'label.project'
                                                    }
                                                },
                                                {
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    projectid: {
                                                        label: 'label.project.id'
                                                    },
                                                    state: {
                                                        label: 'label.state'
                                                    },
                                                    publicip: {
                                                        label: 'label.public.ip'
                                                    },
                                                    guestipaddress: {
                                                        label: 'label.guest.ip'
                                                    },
                                                    linklocalip: {
                                                        label: 'label.linklocal.ip'
                                                    },
                                                    hostname: {
                                                        label: 'label.host'
                                                    },
                                                    serviceofferingname: {
                                                        label: 'label.compute.offering'
                                                    },
                                                    networkdomain: {
                                                        label: 'label.network.domain'
                                                    },
                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    created: {
                                                        label: 'label.created',
                                                        converter: cloudStack.converters.toLocalDate
                                                    },
                                                    isredundantrouter: {
                                                        label: 'label.redundant.router',
                                                        converter: cloudStack.converters.toBooleanText
                                                    },
                                                    redundantRouterState: {
                                                        label: 'label.redundant.state'
                                                    },
                                                    vpcid: {
                                                        label: 'label.vpc.id'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listroutersresponse.router[0];
                                                            addExtraPropertiesToRouterInstanceObject(jsonObj);
                                                            args.response.success({
                                                                actionFilter: routerActionfilter,
                                                                data: jsonObj
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "vpcVirtualRouter"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "vpcVirtualRouter"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    Ovs: {
                        id: "Ovs",
                        label: "label.ovs",
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields: [{
                                    name: {
                                        label: 'label.name'
                                    }
                                }, {
                                    state: {
                                        label: 'label.state'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    },
                                    id: {
                                        label: 'label.id'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    }
                                }],
                                dataProvider: function(args) {
                                    refreshNspData("Ovs");
                                    args.response.success({
                                        actionFilter: ovsProviderActionFilter,
                                        data: $.extend(nspMap["Ovs"], {
                                            supportedServices: nspMap["Ovs"] == undefined? "": nspMap["Ovs"].servicelist.join(', ')
                                        })
                                    });
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["Ovs"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function() {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["Ovs"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function() {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    // NetScaler provider detail view
                    netscaler: {
                        type: 'detailView',
                        id: 'netscalerProvider',
                        label: 'label.netScaler',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.netscalerDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("Netscaler");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "netscaler") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('netscaler')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.netScaler.device',
                                createForm: {
                                    title: 'label.add.netScaler.device',
                                    preFilter: cloudStack.preFilter.addLoadBalancerDevice,
                                    fields: {
                                        ip: {
                                            label: 'label.ip.address',
                                            docID: 'helpNetScalerIPAddress'
                                        },
                                        username: {
                                            label: 'label.username',
                                            docID: 'helpNetScalerUsername'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            docID: 'helpNetScalerPassword'
                                        },
                                        networkdevicetype: {
                                            label: 'label.type',
                                            docID: 'helpNetScalerType',
                                            select: function (args) {
                                                var items =[];
                                                items.push({
                                                    id: "NetscalerMPXLoadBalancer",
                                                    description: "NetScaler MPX LoadBalancer"
                                                });
                                                items.push({
                                                    id: "NetscalerVPXLoadBalancer",
                                                    description: "NetScaler VPX LoadBalancer"
                                                });
                                                items.push({
                                                    id: "NetscalerSDXLoadBalancer",
                                                    description: "NetScaler SDX LoadBalancer"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                        publicinterface: {
                                            label: 'label.public.interface',
                                            docID: 'helpNetScalerPublicInterface'
                                        },
                                        privateinterface: {
                                            label: 'label.private.interface',
                                            docID: 'helpNetScalerPrivateInterface'
                                        },

                                        gslbprovider: {
                                            label: 'label.gslb.service',
                                            isBoolean: true,
                                            isChecked: false
                                        },
                                        gslbproviderpublicip: {
                                            label: 'label.gslb.service.public.ip'
                                        },
                                        gslbproviderprivateip: {
                                            label: 'label.gslb.service.private.ip'
                                        },

                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2',
                                            docID: 'helpNetScalerRetries'
                                        },
                                        // inline: {
                                        //   label: 'Mode',
                                        //   select: function(args) {
                                        //     var items = [];
                                        //     items.push({id: "false", description: "side by side"});
                                        //     items.push({id: "true", description: "inline"});
                                        //     args.response.success({data: items});
                                        //   }
                                        // },
                                        dedicated: {
                                            label: 'label.dedicated',
                                            isBoolean: true,
                                            isChecked: false,
                                            docID: 'helpNetScalerDedicated'
                                        },
                                        capacity: {
                                            label: 'label.capacity',
                                            validation: {
                                                required: false,
                                                number: true
                                            },
                                            docID: 'helpNetScalerCapacity'
                                        }
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.netScaler.device';
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "netscaler"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=Netscaler&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addNetscalerProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addNetscalerProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "netscaler"] = result.jobresult.networkserviceprovider;
                                                                    addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addNetscalerLoadBalancer", "addnetscalerloadbalancerresponse", "netscalerloadbalancer");
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addNetscalerLoadBalancer", "addnetscalerloadbalancerresponse", "netscalerloadbalancer");
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "netscaler"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "netscaler"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "netscaler"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    //Baremetal DHCP provider detail view
                    BaremetalDhcpProvider: {
                        type: 'detailView',
                        id: 'BaremetalDhcpProvider',
                        label: 'label.baremetal.dhcp.provider',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.BaremetalDhcpDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("BaremetalDhcpProvider");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "BaremetalDhcpProvider") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('BaremetalDhcpProvider')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.baremetal.dhcp.device',
                                createForm: {
                                    title: 'label.add.baremetal.dhcp.device',
                                    fields: {
                                        url: {
                                            label: 'label.url',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        username: {
                                            label: 'label.username',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            validation: {
                                                required: true
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    addBaremetalDhcpDeviceFn(args);
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.baremetal.dhcp.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "BaremetalDhcpProvider"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "BaremetalDhcpProvider"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "BaremetalDhcpProvider"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    //Baremetal PXE provider detail view
                    BaremetalPxeProvider: {
                        type: 'detailView',
                        id: 'BaremetalPxeProvider',
                        label: 'label.baremetal.pxe.provider',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.BaremetalPxeDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("BaremetalPxeProvider");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "BaremetalPxeProvider") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('BaremetalPxeProvider')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.baremetal.pxe.device',
                                createForm: {
                                    title: 'label.baremetal.pxe.device',
                                    fields: {
                                        url: {
                                            label: 'label.url',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        username: {
                                            label: 'label.username',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            validation: {
                                                required: true
                                            }
                                        },
                                        tftpdir: {
                                            label: 'label.tftp.root.directory',
                                            validation: {
                                                required: true
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    addBaremetalPxeDeviceFn(args);
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.baremetal.pxe.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "BaremetalPxeProvider"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "BaremetalPxeProvider"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "BaremetalPxeProvider"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    //f5 provider detail view
                    f5: {
                        type: 'detailView',
                        id: 'f5Provider',
                        label: 'label.f5',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.f5Devices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("F5BigIp");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "f5") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('f5')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.F5.device',
                                createForm: {
                                    title: 'label.add.F5.device',
                                    preFilter: cloudStack.preFilter.addLoadBalancerDevice,
                                    fields: {
                                        ip: {
                                            label: 'label.ip.address',
                                            docID: 'helpF5IPAddress'
                                        },
                                        username: {
                                            label: 'label.username',
                                            docID: 'helpF5Username'
                                        },
                                        password: {
                                            label: 'label.password',
                                            docID: 'helpF5Password',
                                            isPassword: true
                                        },
                                        networkdevicetype: {
                                            label: 'label.type',
                                            docID: 'helpF5Type',
                                            select: function (args) {
                                                var items =[];
                                                items.push({
                                                    id: "F5BigIpLoadBalancer",
                                                    description: "F5 Big Ip Load Balancer"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                        publicinterface: {
                                            label: 'label.public.interface',
                                            docID: 'helpF5PublicInterface'
                                        },
                                        privateinterface: {
                                            label: 'label.private.interface',
                                            docID: 'helpF5PrivateInterface'
                                        },
                                        numretries: {
                                            label: 'label.numretries',
                                            docID: 'helpF5Retries',
                                            defaultValue: '2'
                                        },
                                        //Inline Mode has been moved from Add F5 Device to Create Network Offering (both backend and UI)
                                        /*
                                        inline: {
                                        label: 'Mode',
                                        docID: 'helpF5Mode',
                                        select: function(args) {
                                        var items = [];
                                        items.push({id: "false", description: "side by side"});
                                        items.push({id: "true", description: "inline"});
                                        args.response.success({data: items});
                                        }
                                        },
                                         */
                                        dedicated: {
                                            label: 'label.dedicated',
                                            docID: 'helpF5Dedicated',
                                            isBoolean: true,
                                            isChecked: false
                                        },
                                        capacity: {
                                            label: 'label.capacity',
                                            docID: 'helpF5Capacity',
                                            validation: {
                                                required: false,
                                                number: true
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "f5"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=F5BigIp&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addF5ProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addF5ProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "f5"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addF5LoadBalancer", "addf5bigiploadbalancerresponse");
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=F5BigIp failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=F5BigIpfailed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addF5LoadBalancer", "addf5bigiploadbalancerresponse");
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.F5.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "f5"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "f5"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "f5"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    // SRX provider detailView
                    srx: {
                        type: 'detailView',
                        id: 'srxProvider',
                        label: 'label.srx',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.srxDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("JuniperSRX");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "srx") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('srx')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.SRX.device',
                                createForm: {
                                    title: 'label.add.SRX.device',
                                    fields: {
                                        ip: {
                                            label: 'label.ip.address',
                                            docID: 'helpSRXIPAddress'
                                        },
                                        username: {
                                            label: 'label.username',
                                            docID: 'helpSRXUsername'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            docID: 'helpSRXPassword'
                                        },
                                        networkdevicetype: {
                                            label: 'label.type',
                                            docID: 'helpSRXType',
                                            select: function (args) {
                                                var items =[];
                                                items.push({
                                                    id: "JuniperSRXFirewall",
                                                    description: "Juniper SRX Firewall"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                        publicinterface: {
                                            label: 'label.public.interface',
                                            docID: 'helpSRXPublicInterface'
                                        },
                                        privateinterface: {
                                            label: 'label.private.interface',
                                            docID: 'helpSRXPrivateInterface'
                                        },
                                        usageinterface: {
                                            label: 'label.usage.interface',
                                            docID: 'helpSRXUsageInterface'
                                        },
                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2',
                                            docID: 'helpSRXRetries'
                                        },
                                        timeout: {
                                            label: 'label.timeout',
                                            defaultValue: '300',
                                            docID: 'helpSRXTimeout'
                                        },
                                        // inline: {
                                        //   label: 'Mode',
                                        //   docID: 'helpSRXMode',
                                        //   select: function(args) {
                                        //     var items = [];
                                        //     items.push({id: "false", description: "side by side"});
                                        //     items.push({id: "true", description: "inline"});
                                        //     args.response.success({data: items});
                                        //   }
                                        // },
                                        publicnetwork: {
                                            label: 'label.public.network',
                                            defaultValue: 'untrusted',
                                            docID: 'helpSRXPublicNetwork',
                                            isDisabled: true
                                        },
                                        privatenetwork: {
                                            label: 'label.private.network',
                                            defaultValue: 'trusted',
                                            docID: 'helpSRXPrivateNetwork',
                                            isDisabled: true
                                        },
                                        capacity: {
                                            label: 'label.capacity',
                                            validation: {
                                                required: false,
                                                number: true
                                            },
                                            docID: 'helpSRXCapacity'
                                        },
                                        dedicated: {
                                            label: 'label.dedicated',
                                            isBoolean: true,
                                            isChecked: false,
                                            docID: 'helpSRXDedicated'
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "srx"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=JuniperSRX&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addJuniperSRXProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addJuniperSRXProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "srx"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addExternalFirewall(args, selectedPhysicalNetworkObj, "addSrxFirewall", "addsrxfirewallresponse", "srxfirewall");
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=JuniperSRX failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=JuniperSRX failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addExternalFirewall(args, selectedPhysicalNetworkObj, "addSrxFirewall", "addsrxfirewallresponse", "srxfirewall");
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.SRX.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "srx"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "srx"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "srx"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    // Palo Alto provider detailView
                    pa: {
                        type: 'detailView',
                        id: 'paProvider',
                        label: 'label.PA',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.paDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("PaloAlto");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "pa") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('pa')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.PA.device',
                                createForm: {
                                    title: 'label.add.PA.device',
                                    fields: {
                                        ip: {
                                            label: 'label.ip.address',
                                            docID: 'helpPaloAltoIPAddress'
                                        },
                                        username: {
                                            label: 'label.username',
                                            docID: 'helpPaloAltoUsername'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            docID: 'helpPaloAltoPassword'
                                        },
                                        networkdevicetype: {
                                            label: 'label.type',
                                            docID: 'helpPaloAltoType',
                                            select: function (args) {
                                                var items =[];
                                                items.push({
                                                    id: "PaloAltoFirewall",
                                                    description: "Palo Alto Firewall"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                        publicinterface: {
                                            label: 'label.public.interface',
                                            docID: 'helpPaloAltoPublicInterface'
                                        },
                                        privateinterface: {
                                            label: 'label.private.interface',
                                            docID: 'helpPaloAltoPrivateInterface'
                                        },
                                        //usageinterface: {
                                        //  label: 'Usage interface',
                                        //  docID: 'helpPaloAltoUsageInterface'
                                        //},
                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2',
                                            docID: 'helpPaloAltoRetries'
                                        },
                                        timeout: {
                                            label: 'label.timeout',
                                            defaultValue: '300',
                                            docID: 'helpPaloAltoTimeout'
                                        },
                                        // inline: {
                                        //   label: 'Mode',
                                        //   docID: 'helpPaloAltoMode',
                                        //   select: function(args) {
                                        //     var items = [];
                                        //     items.push({id: "false", description: "side by side"});
                                        //     items.push({id: "true", description: "inline"});
                                        //     args.response.success({data: items});
                                        //   }
                                        // },
                                        publicnetwork: {
                                            label: 'label.public.network',
                                            defaultValue: 'untrust',
                                            docID: 'helpPaloAltoPublicNetwork'
                                        },
                                        privatenetwork: {
                                            label: 'label.private.network',
                                            defaultValue: 'trust',
                                            docID: 'helpPaloAltoPrivateNetwork'
                                        },
                                        pavr: {
                                            label: 'label.virtual.router',
                                            docID: 'helpPaloAltoVirtualRouter'
                                        },
                                        patp: {
                                            label: 'label.PA.threat.profile',
                                            docID: 'helpPaloAltoThreatProfile'
                                        },
                                        palp: {
                                            label: 'label.PA.log.profile',
                                            docID: 'helpPaloAltoLogProfile'
                                        },
                                        capacity: {
                                            label: 'label.capacity',
                                            validation: {
                                                required: false,
                                                number: true
                                            },
                                            docID: 'helpPaloAltoCapacity'
                                        },
                                        dedicated: {
                                            label: 'label.dedicated',
                                            isBoolean: true,
                                            isChecked: false,
                                            docID: 'helpPaloAltoDedicated'
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "pa"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=PaloAlto&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addPaloAltoProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addPaloAltoProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "pa"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addExternalFirewall(args, selectedPhysicalNetworkObj, "addPaloAltoFirewall", "addpaloaltofirewallresponse", "pafirewall");
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=Palo Alto failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=Palo Alto failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                3000);
                                            }
                                        });
                                    } else {
                                        addExternalFirewall(args, selectedPhysicalNetworkObj, "addPaloAltoFirewall", "addpaloaltofirewallresponse", "pafirewall");
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.PA.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "pa"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "pa"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "pa"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    // Security groups detail view
                    securityGroups: {
                        id: 'securityGroup-providers',
                        label: 'label.menu.security.groups',
                        type: 'detailView',
                        viewAll: {
                            label: 'label.rules',
                            path: 'network.securityGroups'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("SecurityGroupProvider");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "securityGroups") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        actionFilter: function (args) {
                                            var allowedActions =[];
                                            var jsonObj = providerObj;
                                            if (jsonObj.state == "Enabled")
                                            allowedActions.push("disable"); else if (jsonObj.state == "Disabled")
                                            allowedActions.push("enable");
                                            return allowedActions;
                                        },
                                        data: providerObj
                                    });
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "securityGroups"].id + "&state=Enabled"),
                                        async: true,
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "securityGroups"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },

                        fields: {
                            id: {
                                label: 'label.id'
                            },
                            name: {
                                label: 'label.name'
                            }
                            //,
                            //state: { label: 'label.status' } //comment it for now, since dataProvider below doesn't get called by widget code after action is done
                        }
                    },
                    // Nicira Nvp provider detail view
                    niciraNvp: {
                        type: 'detailView',
                        id: 'niciraNvpProvider',
                        label: 'label.niciraNvp',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.niciraNvpDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("NiciraNvp");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "niciraNvp") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('niciraNvp')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.NiciraNvp.device',
                                createForm: {
                                    title: 'label.add.NiciraNvp.device',
                                    preFilter: function (args) {
                                    },
                                    // TODO What is this?
                                    fields: {
                                        host: {
                                            label: 'label.ip.address'
                                        },
                                        username: {
                                            label: 'label.username'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true
                                        },
                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2'
                                        },
                                        transportzoneuuid: {
                                            label: 'label.nicira.transportzoneuuid'
                                        },
                                        l3gatewayserviceuuid: {
                                            label: 'label.nicira.l3gatewayserviceuuid'
                                        },
										l2gatewayserviceuuid: {
                                            label: 'label.nicira.l2gatewayserviceuuid'
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "niciraNvp"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=NiciraNvp&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addNiciraNvpProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addNiciraNvpProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "niciraNvp"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addNiciraNvpDevice(args, selectedPhysicalNetworkObj, "addNiciraNvpDevice", "addniciranvpdeviceresponse", "niciranvpdevice")
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=NiciraNvp failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=NiciraNvp failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addNiciraNvpDevice(args, selectedPhysicalNetworkObj, "addNiciraNvpDevice", "addniciranvpdeviceresponse", "niciranvpdevice")
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.NiciraNvp.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "niciraNvp"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "niciraNvp"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "niciraNvp"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },
                    // Brocade Vcs provider detail view
                    brocadeVcs: {
                        type: 'detailView',
                        id: 'brocadeVcsProvider',
                        label: 'label.brocadeVcs',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.brocadeVcsDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("BrocadeVcs");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "brocadeVcs") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('brocadeVcs')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.BrocadeVcs.device',
                                createForm: {
                                    title: 'label.add.BrocadeVcs.device',
                                    preFilter: function (args) {
                                    },
                                    // TODO What is this?
                                    fields: {
                                        host: {
                                            label: 'label.ip.address'
                                        },
                                        username: {
                                            label: 'label.username'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "brocadeVcs"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=BrocadeVcs&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addBrocadeVcsProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addBrocadeVcsProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "brocadeVcs"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addBrocadeVcsDevice(args, selectedPhysicalNetworkObj, "addBrocadeVcsDevice", "addbrocadevcsdeviceresponse", "brocadevcsdevice")
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=BrocadeVcs failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=BrocadeVcs failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addBrocadeVcsDevice(args, selectedPhysicalNetworkObj, "addBrocadeVcsDevice", "addbrocadevcsdeviceresponse", "brocadevcsdevice")
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.BrocadeVcs.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "brocadeVcs"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "brocadeVcs"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "brocadeVcs"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },
                    // BigSwitch BCF provider detail view
                    bigswitchBcf: {
                        type: 'detailView',
                        id: 'bigswitchBcfProvider',
                        label: 'label.bigswitchBcf',
                        viewAll: {
                            label: 'label.devices',
                            path: '_zone.bigswitchBcfDevices'
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("BigSwitchBcf");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "bigswitchBcf") {
                                            providerObj = this;
                                            return false;
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('bigswitchBcf')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.BigSwitchBcf.device',
                                createForm: {
                                    title: 'label.add.BigSwitchBcf.device',
                                    preFilter: function (args) {
                                    },
                                    fields: {
                                        host: {
                                            label: 'label.host.name'
                                        },
                                        username: {
                                            label: 'label.username'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true
                                        },
                                        nat: {
                                                label: 'label.bigswitch.bcf.nat',
                                                isBoolean: true,
                                                isChecked: false
                                        },
                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2'
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "bigswitchBcf"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=BigSwitchBcf&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addBigSwitchBcfProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addBigSwitchBcfProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "bigswitchBcf"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addBigSwitchBcfDevice(args, selectedPhysicalNetworkObj, "addBigSwitchBcfDevice", "addbigswitchbcfdeviceresponse", "bigswitchbcfdevice")
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=BigSwitchBcf failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=BigSwitchBcf failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                3000);
                                            }
                                        });
                                    } else {
                                        addBigSwitchBcfDevice(args, selectedPhysicalNetworkObj, "addBigSwitchBcfDevice", "addbigswitchbcfdeviceresponse", "bigswitchbcfdevice")
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.BigSwitchBcf.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "bigswitchBcf"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "bigswitchBcf"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "bigswitchBcf"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    //ovs
                    Ovs: {
                        id: 'ovsProviders',
                        label: 'label.ovs',
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            ipaddress: {
                                label: 'label.ip.address'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    },
                                    destinationphysicalnetworkid: {
                                        label: 'label.destination.physical.network.id'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("Ovs");
                                    args.response.success({
                                        actionFilter: virtualRouterProviderActionFilter,
                                        data: $.extend(nspMap[ "Ovs"], {
                                            supportedServices: nspMap["Ovs"] == undefined? "": nspMap["Ovs"].servicelist.join(', ')
                                        })
                                    });
                                }
                            },

                            instances: {
                                title: 'label.instances',
                                listView: {
                                    label: 'label.virtual.appliances',
                                    id: 'routers',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        zonename: {
                                            label: 'label.zone'
                                        },
                                        routerType: {
                                            label: 'label.type'
                                        },
                                        state: {
                                            converter: function (str) {
                                                // For localization
                                                return str;
                                            },
                                            label: 'label.status',
                                            indicator: {
                                                'Running': 'on',
                                                'Stopped': 'off',
                                                'Error': 'off'
                                            }
                                        }
                                    },
                                    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;
                                                }
                                            }
                                        }

                                        var data2 = {
                                            forvpc: false
                                        };
                                        var routers =[];
                                        $.ajax({
                                            url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                            data: data2,
                                            success: function (json) {
                                                var items = json.listroutersresponse.router ?
                                                json.listroutersresponse.router:[];

                                                $(items).map(function (index, item) {
                                                    routers.push(item);
                                                });

                                                // Get project routers
                                                $.ajax({
                                                    url: createURL("listRouters&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("") + "&projectid=-1"),
                                                    data: data2,
                                                    success: function (json) {
                                                        var items = json.listroutersresponse.router ?
                                                        json.listroutersresponse.router:[];

                                                        $(items).map(function (index, item) {
                                                            routers.push(item);
                                                        });
                                                        args.response.success({
                                                            actionFilter: routerActionfilter,
                                                            data: $(routers).map(mapRouterType)
                                                        });
                                                    }
                                                });
                                            }
                                        });
                                    },
                                    detailView: {
                                        name: 'label.virtual.appliance.details',
                                        actions: {
                                            start: {
                                                label: 'label.action.start.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.start.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.start.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL('startRouter&id=' + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.startrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.domainrouter;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            stop: {
                                                label: 'label.action.stop.router',
                                                createForm: {
                                                    title: 'label.action.stop.router',
                                                    desc: 'message.action.stop.router',
                                                    fields: {
                                                        forced: {
                                                            label: 'force.stop',
                                                            isBoolean: true,
                                                            isChecked: false
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.stop.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    var array1 =[];
                                                    array1.push("&forced=" + (args.data.forced == "on"));
                                                    $.ajax({
                                                        url: createURL('stopRouter&id=' + args.context.routers[0].id + array1.join("")),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.stoprouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        return json.queryasyncjobresultresponse.jobresult.domainrouter;
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            'remove': {
                                                label: 'label.destroy.router',
                                                messages: {
                                                    confirm: function (args) {
                                                        if (args && args.context && args.context.routers[0]) {
                                                            if (args.context.routers[0].state == 'Running') {
                                                                return dictionary['message.action.stop.router'] + ' ' + dictionary['message.confirm.destroy.router'];
                                                            }
                                                        }
                                                        return 'message.confirm.destroy.router';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.destroy.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("destroyRouter&id=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.destroyrouterresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            migrate: {
                                                label: 'label.action.migrate.router',
                                                createForm: {
                                                    title: 'label.action.migrate.router',
                                                    desc: '',
                                                    fields: {
                                                        hostId: {
                                                            label: 'label.host',
                                                            validation: {
                                                                required: true
                                                            },
                                                            select: function (args) {
                                                                $.ajax({
                                                                    url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.routers[0].id),
                                                                    dataType: "json",
                                                                    async: true,
                                                                    success: function (json) {
                                                                        var hostObjs = json.findhostsformigrationresponse.host;
                                                                        var items =[];
                                                                        $(hostObjs).each(function () {
                                                                            items.push({
                                                                                id: this.id,
                                                                                description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                            });
                                                                        });
                                                                        args.response.success({
                                                                            data: items
                                                                        });
                                                                    }
                                                                });
                                                            },
                                                            error: function (XMLHttpResponse) {
                                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                args.response.error(errorMsg);
                                                            }
                                                        }
                                                    }
                                                },
                                                messages: {
                                                    notification: function (args) {
                                                        return 'label.action.migrate.router';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.routers[0].id),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.migratesystemvmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                        $.ajax({
                                                                            url: createURL("listRouters&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                            dataType: "json",
                                                                            async: false,
                                                                            success: function (json) {
                                                                                var items = json.listroutersresponse.router;
                                                                                if (items != null && items.length > 0) {
                                                                                    return items[0];
                                                                                }
                                                                            }
                                                                        });
                                                                    },
                                                                    getActionFilter: function () {
                                                                        return routerActionfilter;
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            },

                                            viewConsole: {
                                                label: 'label.view.console',
                                                action: {
                                                    externalLink: {
                                                        url: function (args) {
                                                            return clientConsoleUrl + '?cmd=access&vm=' + args.context.routers[0].id;
                                                        },
                                                        title: function (args) {
                                                            return args.context.routers[0].id.substr(0, 8);
                                                            //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                        },
                                                        width: 820,
                                                        height: 640
                                                    }
                                                }
                                            }
                                        },
                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                preFilter: function (args) {
                                                    var hiddenFields =[];
                                                    if (! args.context.routers[0].project) {
                                                        hiddenFields.push('project');
                                                        hiddenFields.push('projectid');
                                                    }
                                                    if (selectedZoneObj.networktype == 'Basic') {
                                                        hiddenFields.push('publicip');
                                                        //In Basic zone, guest IP is public IP. So, publicip is not returned by listRouters API. Only guestipaddress is returned by listRouters API.
                                                    }

                                                    if ('routers' in args.context && args.context.routers[0].vpcid != undefined) {
                                                        hiddenFields.push('guestnetworkid');
                                                        hiddenFields.push('guestnetworkname');
                                                    } else if ('routers' in args.context && args.context.routers[0].guestnetworkid != undefined) {
                                                        hiddenFields.push('vpcid');
                                                        hiddenFields.push('vpcname');
                                                    }

                                                    return hiddenFields;
                                                },
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name'
                                                    },
                                                    project: {
                                                        label: 'label.project'
                                                    }
                                                },
                                                {
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    projectid: {
                                                        label: 'label.project.id'
                                                    },
                                                    state: {
                                                        label: 'label.state'
                                                    },
                                                    guestnetworkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    guestnetworkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    vpcid: {
                                                        label: 'label.vpc.id'
                                                    },
                                                    vpcname: {
                                                        label: 'label.vpc'
                                                    },
                                                    publicip: {
                                                        label: 'label.public.ip'
                                                    },
                                                    guestipaddress: {
                                                        label: 'label.guest.ip'
                                                    },
                                                    linklocalip: {
                                                        label: 'label.linklocal.ip'
                                                    },
                                                    hostname: {
                                                        label: 'label.host'
                                                    },
                                                    serviceofferingname: {
                                                        label: 'label.compute.offering'
                                                    },
                                                    networkdomain: {
                                                        label: 'label.network.domain'
                                                    },
                                                    domain: {
                                                        label: 'label.domain'
                                                    },
                                                    account: {
                                                        label: 'label.account'
                                                    },
                                                    created: {
                                                        label: 'label.created',
                                                        converter: cloudStack.converters.toLocalDate
                                                    },
                                                    isredundantrouter: {
                                                        label: 'label.redundant.router',
                                                        converter: cloudStack.converters.toBooleanText
                                                    },
                                                    redundantRouterState: {
                                                        label: 'label.redundant.state'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listroutersresponse.router[0];
                                                            addExtraPropertiesToRouterInstanceObject(jsonObj);
                                                            args.response.success({
                                                                actionFilter: routerActionfilter,
                                                                data: jsonObj
                                                            });
                                                        }
                                                    });
                                                }
                                            },
                                            nics: {
                                                title: 'label.nics',
                                                multiple: true,
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name',
                                                        header: true
                                                    },
                                                    type: {
                                                        label: 'label.type'
                                                    },
                                                    traffictype: {
                                                        label: 'label.traffic.type'
                                                    },
                                                    networkname: {
                                                        label: 'label.network.name'
                                                    },
                                                    netmask: {
                                                        label: 'label.netmask'
                                                    },
                                                    ipaddress: {
                                                        label: 'label.ip.address'
                                                    },
                                                    id: {
                                                        label: 'label.id'
                                                    },
                                                    networkid: {
                                                        label: 'label.network.id'
                                                    },
                                                    isolationuri: {
                                                        label: 'label.isolation.uri'
                                                    },
                                                    broadcasturi: {
                                                        label: 'label.broadcast.uri'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                        dataType: 'json',
                                                        async: true,
                                                        success: function (json) {
                                                            var jsonObj = json.listroutersresponse.router[0].nic;

                                                            args.response.success({
                                                                actionFilter: routerActionfilter,
                                                                data: $.map(jsonObj, function (nic, index) {
                                                                    var name = 'NIC ' + (index + 1);
                                                                    if (nic.isdefault) {
                                                                        name += ' (' + _l('label.default') + ')';
                                                                    }
                                                                    return $.extend(nic, {
                                                                        name: name
                                                                    });
                                                                })
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "Ovs"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "Ovs"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    Opendaylight: {
                        type: 'detailView',
                        id: 'openDaylightProvider',
                        label: 'label.openDaylight',
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function (args) {
                                    refreshNspData("Opendaylight");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function () {
                                        if (this.id == "Opendaylight") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('Opendaylight')
                                    });
                                }
                            },
                            controllers: {
                                title: 'label.opendaylight.controllers',
                                listView: {
                                    id: 'openDaylightControllerList',
                                    fields: {
                                        name: {
                                            label: 'label.name'
                                        },
                                        url: {
                                            label: 'label.url'
                                        },
                                        username: {
                                            label: 'label.username'
                                        }
                                    },
                                    dataProvider: function (args) {
                                        var providerObj
                                        $.ajax({
                                            url: createURL("listOpenDaylightControllers"),
                                            async: false,
                                            success: function (json) {
                                                providerObj = json.listOpenDaylightControllers.opendaylightcontroller
                                            }
                                        });
                                        args.response.success({
                                            data: providerObj
                                        });
                                    },
                                    detailView: {
                                        name: "OpenDaylight Controller",
                                        tabs: {
                                            details: {
                                                title: 'label.opendaylight.controllerdetail',
                                                fields:[ {
                                                    name: {
                                                        label: 'label.name'
                                                    },
                                                    url: {
                                                        label: 'label.url', header: true
                                                    },
                                                    username: {
                                                        label: 'label.username'
                                                    }
                                                }],
                                                dataProvider: function (args) {
                                                    var providerObj
                                                    $.ajax({
                                                        url: createURL("listOpenDaylightControllers&id=" + args.id),
                                                        async: false,
                                                        success: function (json) {
                                                            providerObj = json.listOpenDaylightControllers.opendaylightcontroller
                                                        }
                                                    });
                                                    args.response.success({
                                                        data: providerObj[0],
                                                        actionFilter: function(args) { return [ 'destroy' ] }
                                                    });
                                                }
                                            }
                                        },
                                        actions: {
                                            destroy: {
                                                label: 'label.delete.OpenDaylight.device',
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("deleteOpenDaylightController&id=" + args.data.id),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var jid = json.deleteOpenDaylightController.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid,
                                                                    getUpdatedItem: function (json) {
                                                                        $(window).trigger('cloudStack.fullRefresh');
                                                                    }
                                                                }
                                                            });
                                                        }
                                                    });
                                                },
                                                messages: {
                                                    notification: function(args) {
                                                        return 'label.openaylight.destroycontroller'
                                                    }
                                                },
                                                notification: {
                                                    poll: pollAsyncJobResult
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.add.OpenDaylight.device',
                                createForm: {
                                    title: 'label.add.OpenDaylight.device',
                                    preFilter: function (args) {
                                    },
                                    // TODO What is this?
                                    fields: {
                                        url: {
                                            label: 'label.url'
                                        },
                                        username: {
                                            label: 'label.username'
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true
                                        },
                                        numretries: {
                                            label: 'label.numretries',
                                            defaultValue: '2'
                                        }
                                    }
                                },
                                action: function (args) {
                                    if (nspMap[ "Opendaylight"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=Opendaylight&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function (json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addOpenDaylightProviderIntervalID = setInterval(function () {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addOpenDaylightProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap[ "Opendaylight"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addOpenDaylightController(args, selectedPhysicalNetworkObj, "addOpenDaylightController", "addopendaylightcontrollerresponse", "opendaylightcontroller")
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=OpenDaylight failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=OpenDaylight failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                },
                                                g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addOpenDaylightController(args, selectedPhysicalNetworkObj, "addOpenDaylightController", "addOpenDaylightController", "opendaylightcontroller")
                                    }
                                },
                                messages: {
                                    notification: function (args) {
                                        return 'label.add.OpenDaylight.device';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "Opendaylight"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function () {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap[ "Opendaylight"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function () {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap[ "Opendaylight"].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function (args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    // GloboDns provider detail view
                    GloboDns: {
                        isMaximized: true,
                        type: 'detailView',
                        id: 'globoDnsProvider',
                        label: 'label.globo.dns',
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields: [{
                                    name: {
                                        label: 'label.name'
                                    }
                                }, {
                                    state: {
                                        label: 'label.state'
                                    }
                                }],
                                dataProvider: function(args) {
                                    refreshNspData("GloboDns");
                                    var providerObj;
                                    $(nspHardcodingArray).each(function() {
                                        if (this.id == "GloboDns") {
                                            providerObj = this;
                                            return false; //break each loop
                                        }
                                    });
                                    args.response.success({
                                        data: providerObj,
                                        actionFilter: networkProviderActionFilter('GloboDns')
                                    });
                                }
                            }
                        },
                        actions: {
                            add: {
                                label: 'label.globo.dns.configuration',
                                createForm: {
                                    title: 'label.globo.dns.configuration',
                                    preFilter: function(args) {},
                                    fields: {
                                        username: {
                                            label: 'label.username',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        password: {
                                            label: 'label.password',
                                            isPassword: true,
                                            validation: {
                                                required: true
                                            }
                                        },
                                        url: {
                                            label: 'label.url',
                                            validation: {
                                                required: true
                                            }
                                        }
                                    }
                                },
                                action: function(args) {
                                    if (nspMap["GloboDns"] == null) {
                                        $.ajax({
                                            url: createURL("addNetworkServiceProvider&name=GloboDns&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                            dataType: "json",
                                            async: true,
                                            success: function(json) {
                                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                                var addGloboDnsProviderIntervalID = setInterval(function() {
                                                    $.ajax({
                                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                        dataType: "json",
                                                        success: function(json) {
                                                            var result = json.queryasyncjobresultresponse;
                                                            if (result.jobstatus == 0) {
                                                                return; //Job has not completed
                                                            } else {
                                                                clearInterval(addGloboDnsProviderIntervalID);
                                                                if (result.jobstatus == 1) {
                                                                    nspMap["GloboDns"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                    addGloboDnsHost(args, selectedPhysicalNetworkObj, "addGloboDnsHost", "addglobodnshostresponse");
                                                                } else if (result.jobstatus == 2) {
                                                                    alert("addNetworkServiceProvider&name=GloboDns failed. Error: " + _s(result.jobresult.errortext));
                                                                }
                                                            }
                                                        },
                                                        error: function(XMLHttpResponse) {
                                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                            alert("addNetworkServiceProvider&name=GloboDns failed. Error: " + errorMsg);
                                                        }
                                                    });
                                                }, g_queryAsyncJobResultInterval);
                                            }
                                        });
                                    } else {
                                        addGloboDnsHost(args, selectedPhysicalNetworkObj, "addGloboDnsHost", "addglobodnshostresponse");
                                    }
                                },
                                messages: {
                                    notification: function(args) {
                                        return 'label.add.globo.dns';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enable: {
                                label: 'label.enable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["GloboDns"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function() {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["GloboDns"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function() {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            destroy: {
                                label: 'label.shutdown.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("deleteNetworkServiceProvider&id=" + nspMap["GloboDns"].id),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.deletenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });

                                            $(window).trigger('cloudStack.fullRefresh');
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.shutdown.provider';
                                    },
                                    notification: function(args) {
                                        return 'label.shutdown.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    },

                    ConfigDrive: {
                        id: "ConfigDrive",
                        label: "ConfigDrive",
                        isMaximized: true,
                        type: 'detailView',
                        fields: {
                            name: {
                                label: 'label.name'
                            },
                            state: {
                                label: 'label.status',
                                indicator: {
                                    'Enabled': 'on'
                                }
                            }
                        },
                        tabs: {
                            network: {
                                title: 'label.network',
                                fields: [{
                                    name: {
                                        label: 'label.name'
                                    }
                                }, {
                                    state: {
                                        label: 'label.state'
                                    },
                                    supportedServices: {
                                        label: 'label.supported.services'
                                    },
                                    id: {
                                        label: 'label.id'
                                    },
                                    physicalnetworkid: {
                                        label: 'label.physical.network.ID'
                                    }
                                }],
                                dataProvider: function(args) {
                                    refreshNspData("ConfigDrive");
                                    args.response.success({
                                        actionFilter: ovsProviderActionFilter,
                                        data: $.extend(nspMap["ConfigDrive"], {
                                            supportedServices: nspMap["ConfigDrive"] == undefined? "": nspMap["ConfigDrive"].servicelist.join(', ')
                                        })
                                    });
                                }
                            }
                        },
                        actions: {
                            enable: {
                                label: 'label.enable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["ConfigDrive"].id + "&state=Enabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.enable.provider';
                                    },
                                    notification: function() {
                                        return 'label.enable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disable: {
                                label: 'label.disable.provider',
                                action: function(args) {
                                    $.ajax({
                                        url: createURL("updateNetworkServiceProvider&id=" + nspMap["ConfigDrive"].id + "&state=Disabled"),
                                        dataType: "json",
                                        success: function(json) {
                                            var jid = json.updatenetworkserviceproviderresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function(json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function(args) {
                                        return 'message.confirm.disable.provider';
                                    },
                                    notification: function() {
                                        return 'label.disable.provider';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        }
                    }
                }
            }
        },
        physicalResourceSection: {
            sections: {
                physicalResources: {
                    type: 'select',
                    title: 'label.menu.physical.resources',
                    listView: {
                        zones: {
                            id: 'physicalResources',
                            label: 'label.menu.physical.resources',
                            multiSelect: true,
                            fields: {
                                name: {
                                    label: 'label.zone'
                                },
                                networktype: {
                                    label: 'label.network.type'
                                },
                                domainid: {
                                    label: 'label.public',
                                    converter: function (args) {
                                        if (args == null)
                                        return "Yes"; else
                                        return "No";
                                    }
                                },
                                allocationstate: {
                                    label: 'label.allocation.state',
                                    converter: function (str) {
                                        // For localization
                                        return str;
                                    },
                                    indicator: {
                                        'Enabled': 'on',
                                        'Disabled': 'off'
                                    }
                                }
                            },

                            reorder: cloudStack.api.actions.sort('updateZone', 'physicalResources'),

                            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("listZones&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        zoneObjs = json.listzonesresponse.zone;
                                        args.response.success({
                                            actionFilter: zoneActionfilter,
                                            data: zoneObjs
                                        });
                                    }
                                });
                            },

                            actions: {
                                add: {
                                    label: 'label.add.zone',
                                    action: {
                                        custom: cloudStack.uiCustom.zoneWizard(
                                        cloudStack.zoneWizard)
                                    },
                                    messages: {
                                        notification: function (args) {
                                            return 'label.add.zone';
                                        }
                                    },
                                    notification: {
                                        poll: function (args) {
                                            args.complete({
                                                actionFilter: zoneActionfilter,
                                                data: args._custom.zone
                                            });
                                        }
                                    }
                                },
                                viewMetrics: {
                                    label: 'label.metrics',
                                    isHeader: true,
                                    addRow: false,
                                    action: {
                                        custom: cloudStack.uiCustom.metricsView({resource: 'zones'})
                                    },
                                    messages: {
                                        notification: function (args) {
                                            return 'label.metrics';
                                        }
                                    }
                                },
                                startRollingMaintenance: rollingMaintenanceAction({ listView: true, entity: 'zones' })
                            },

                            detailView: {
                                isMaximized: true,
                                actions: {

                                    startRollingMaintenance: {
                                        label: 'label.start.rolling.maintenance',
                                        textLabel: 'label.start.rolling.maintenance',
                                        messages: {
                                            notification: function (args) {
                                                return 'label.start.rolling.maintenance';
                                            }
                                        },
                                        createForm: {
                                            title: 'label.start.rolling.maintenance',
                                            fields: {
                                                timeout: {
                                                    label: 'label.timeout',
                                                },
                                                force: {
                                                    isBoolean: true,
                                                    label: 'label.start.rolling.maintenance.force'
                                                },
                                                payload: {
                                                    label: 'label.start.rolling.maintenance.payload'
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            var data = {
                                                zoneids: args.context.physicalResources[0].id,
                                                force: args.data.force,
                                                timeout: args.data.timeout,
                                                payload: args.data.payload
                                            };
                                            $.ajax({
                                                url: createURL("startRollingMaintenance"),
                                                dataType: "json",
                                                data: data,
                                                async: true,
                                                success: function (json) {
                                                    var item = json.rollingmaintenance;
                                                    args.response.success({
                                                        actionFilter: zoneActionfilter,
                                                        data: item
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    addVmwareDc: {
                                        label: 'label.add.vmware.datacenter',
                                        textLabel: 'label.add.vmware.datacenter',
                                        messages: {
                                            notification: function (args) {
                                                return 'label.add.vmware.datacenter';
                                            }
                                        },
                                        createForm: {
                                            title: 'label.add.vmware.datacenter',
                                            fields: {
                                                name: {
                                                    label: 'label.dc.name',
                                                    validation: {
                                                        required: true
                                                    }
                                                },
                                                vcenter: {
                                                    label: 'label.vcenter',
                                                    validation: {
                                                        required: true
                                                    }
                                                },
                                                username: {
                                                    label: 'label.username',
                                                    validation: {
                                                        required: true
                                                    }
                                                },
                                                password: {
                                                    label: 'label.password',
                                                    isPassword: true,
                                                    validation: {
                                                        required: true
                                                    }
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id,
                                                name: args.data.name,
                                                vcenter: args.data.vcenter
                                            };

                                            if (args.data.username != null && args.data.username.length > 0) {
                                                $.extend(data, {
                                                    username: args.data.username
                                                })
                                            }
                                            if (args.data.password != null && args.data.password.length > 0) {
                                                $.extend(data, {
                                                    password: args.data.password
                                                })
                                            }

                                            $.ajax({
                                                url: createURL('addVmwareDc'),
                                                data: data,
                                                type: "POST",
                                                success: function (json) {
                                                    //var item = json.addvmwaredcresponse.vmwaredc;
                                                    args.response.success();
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    updateVmwareDc: {
                                        label: 'label.update.vmware.datacenter',
                                        messages: {
                                            confirm: function (args) {
                                                return 'label.update.vmware.datacenter';
                                            },
                                            notification: function (args) {
                                                return 'label.update.vmware.datacenter';
                                            }
                                        },
                                        createForm: {
                                            title: 'label.update.vmware.datacenter',
                                            fields: {
                                                name: {
                                                    label: 'label.vmware.datacenter.name'
                                                },
                                                vcenter: {
                                                    label: 'label.vmware.datacenter.vcenter'
                                                },
                                                username: {
                                                    label: 'label.username'
                                                },
                                                password: {
                                                    label: 'label.password',
                                                    isPassword: true
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            var data = args.data;
                                            data.zoneid = args.context.physicalResources[0].id;
                                            $.ajax({
                                                url: createURL('updateVmwareDc'),
                                                data: data,
                                                success: function (json) {
                                                    args.response.success({
                                                        data: args.context.physicalResources[0]
                                                    });
                                                },
                                                error: function (XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    removeVmwareDc: {
                                        label: 'label.remove.vmware.datacenter',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.remove.vmware.datacenter';
                                            },
                                            notification: function (args) {
                                                return 'label.remove.vmware.datacenter';
                                            }
                                        },
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id
                                            };
                                            $.ajax({
                                                url: createURL('removeVmwareDc'),
                                                data: data,
                                                success: function (json) {
                                                    delete args.context.physicalResources[0].vmwaredcName;
                                                    delete args.context.physicalResources[0].vmwaredcVcenter;
                                                    delete args.context.physicalResources[0].vmwaredcId;

                                                    selectedZoneObj = args.context.physicalResources[0];

                                                    args.response.success({
                                                        data: args.context.physicalResources[0]
                                                    });
                                                },
                                                error: function (XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    enable: {
                                        label: 'label.action.enable.zone',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.enable.zone';
                                            },
                                            notification: function (args) {
                                                return 'label.action.enable.zone';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("updateZone&id=" + args.context.physicalResources[0].id + "&allocationstate=Enabled"), //embedded objects in listView is called physicalResources while embedded objects in detailView is called zones
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var item = json.updatezoneresponse.zone;
                                                    args.response.success({
                                                        actionFilter: zoneActionfilter,
                                                        data: item
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    disable: {
                                        label: 'label.action.disable.zone',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.disable.zone';
                                            },
                                            notification: function (args) {
                                                return 'label.action.disable.zone';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("updateZone&id=" + args.context.physicalResources[0].id + "&allocationstate=Disabled"), //embedded objects in listView is called physicalResources while embedded objects in detailView is called zones
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var item = json.updatezoneresponse.zone;
                                                    args.response.success({
                                                        actionFilter: zoneActionfilter,
                                                        data: item
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },

                                    dedicateZone: {
                                        label: 'label.dedicate.zone',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.dedicate.zone';
                                            },
                                            notification: function (args) {
                                                return 'label.zone.dedicated';
                                            }
                                        },
                                        createForm: {
                                            title: 'label.dedicate.zone',
                                            fields: {
                                                domainId: {
                                                    label: 'label.domain',
                                                    validation: {
                                                        required: true
                                                    },
                                                    select: function (args) {
                                                        $.ajax({
                                                            url: createURL('listDomains'),
                                                            data: {
                                                                listAll: true,
                                                                details: 'min'
                                                            },
                                                            dataType: "json",
                                                            async: false,
                                                            success: function (json) {
                                                                var domainObjs = json.listdomainsresponse.domain;
                                                                var items =[];

                                                                $(domainObjs).each(function () {
                                                                    items.push({
                                                                        id: this.id,
                                                                        description: this.name
                                                                    });
                                                                });
                                                                items.sort(function(a, b) {
                                                                    return a.description.localeCompare(b.description);
                                                                });

                                                                args.response.success({
                                                                    data: items
                                                                });
                                                            }
                                                        });
                                                    }
                                                },
                                                accountId: {
                                                    label: 'label.account',
                                                    docID: 'helpAccountForDedication',
                                                    validation: {
                                                        required: false
                                                    }
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            //EXPLICIT DEDICATION
                                            var array2 =[];
                                            if (args.data.accountId != "")
                                            array2.push("&account=" + encodeURIComponent(args.data.accountId));

                                            $.ajax({
                                                url: createURL("dedicateZone&zoneId=" +
                                                args.context.physicalResources[0].id +
                                                "&domainId=" + args.data.domainId + array2.join("")),
                                                dataType: "json",
                                                success: function (json) {
                                                    var jid = json.dedicatezoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },
                                    releaseDedicatedZone: {
                                        label: 'label.release.dedicated.zone',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.release.dedicated.zone';
                                            },
                                            notification: function (args) {
                                                return 'message.dedicated.zone.released';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("releaseDedicatedZone&zoneid=" +
                                                args.context.physicalResources[0].id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.releasededicatedzoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    'remove': {
                                        label: 'label.action.delete.zone',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.delete.zone';
                                            },
                                            notification: function (args) {
                                                return 'label.action.delete.zone';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("deleteZone&id=" + args.context.physicalResources[0].id), //embedded objects in listView is called physicalResources while embedded objects in detailView is called zones
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    args.response.success({
                                                        data: {
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    },
                                    edit: {
                                        label: 'label.edit',
                                        action: function (args) {
                                            var array1 =[];
                                            array1.push("&name=" + encodeURIComponent(args.data.name));
                                            array1.push("&dns1=" + encodeURIComponent(args.data.dns1));
                                            array1.push("&dns2=" + encodeURIComponent(args.data.dns2));
                                            //dns2 can be empty ("") when passed to API, so a user gets to update this field from an existing value to blank.
                                            array1.push("&ip6dns1=" + encodeURIComponent(args.data.ip6dns1));
                                            //p6dns1 can be empty ("") when passed to API, so a user gets to update this field from an existing value to blank.
                                            array1.push("&ip6dns2=" + encodeURIComponent(args.data.ip6dns2));
                                            //ip6dns2 can be empty ("") when passed to API, so a user gets to update this field from an existing value to blank.

                                            if (selectedZoneObj.networktype == "Advanced" && args.data.guestcidraddress) {
                                                array1.push("&guestcidraddress=" + encodeURIComponent(args.data.guestcidraddress));
                                            }

                                            array1.push("&internaldns1=" + encodeURIComponent(args.data.internaldns1));
                                            array1.push("&internaldns2=" + encodeURIComponent(args.data.internaldns2));
                                            //internaldns2 can be empty ("") when passed to API, so a user gets to update this field from an existing value to blank.
                                            array1.push("&domain=" + encodeURIComponent(args.data.domain));
                                            array1.push("&localstorageenabled=" + (args.data.localstorageenabled == 'on'));
                                            $.ajax({
                                                url: createURL("updateZone&id=" + args.context.physicalResources[0].id + array1.join("")),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    selectedZoneObj = json.updatezoneresponse.zone; //override selectedZoneObj after update zone
                                                    args.response.success({
                                                        data: selectedZoneObj
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error('Could not edit zone information; please ensure all fields are valid.');
                                                }
                                            });
                                        }
                                    },
                                    enableOutOfBandManagement: {
                                        label: 'label.outofbandmanagement.enable',
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id
                                            };
                                            $.ajax({
                                                url: createURL("enableOutOfBandManagementForZone"),
                                                data: data,
                                                success: function (json) {
                                                    var jid = json.enableoutofbandmanagementforzoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }

                                            });
                                        },
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.outofbandmanagement.enable';
                                            },
                                            notification: function (args) {
                                                return 'message.outofbandmanagement.enable';
                                            }
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },
                                    disableOutOfBandManagement: {
                                        label: 'label.outofbandmanagement.disable',
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id
                                            };
                                            $.ajax({
                                                url: createURL("disableOutOfBandManagementForZone"),
                                                data: data,
                                                success: function (json) {
                                                    var jid = json.disableoutofbandmanagementforzoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }

                                            });
                                        },
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.outofbandmanagement.disable';
                                            },
                                            notification: function (args) {
                                                return 'message.outofbandmanagement.disable';
                                            }
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },
                                    enableHA: {
                                        label: 'label.ha.enable',
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id
                                            };
                                            $.ajax({
                                                url: createURL("enableHAForZone"),
                                                data: data,
                                                success: function (json) {
                                                    var jid = json.enablehaforzoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        },
                                        messages: {
                                            confirm: function (args) {
                                                return 'label.ha.enable';
                                            },
                                            notification: function (args) {
                                                return 'label.ha.enable';
                                            }
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },
                                    disableHA: {
                                        label: 'label.ha.disable',
                                        action: function (args) {
                                            var data = {
                                                zoneid: args.context.physicalResources[0].id
                                            };
                                            $.ajax({
                                                url: createURL("disableHAForZone"),
                                                data: data,
                                                success: function (json) {
                                                    var jid = json.disablehaforzoneresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getActionFilter: function () {
                                                                return zoneActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        },
                                        messages: {
                                            confirm: function (args) {
                                                return 'label.ha.disable';
                                            },
                                            notification: function (args) {
                                                return 'label.ha.disable';
                                            }
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.details',

                                        preFilter: function (args) {
                                            var hiddenFields =[];
                                            if (selectedZoneObj.networktype == "Basic")
                                            hiddenFields.push("guestcidraddress");
                                            return hiddenFields;
                                        },

                                        fields:[ {
                                            name: {
                                                label: 'label.zone',
                                                isEditable: true,
                                                validation: {
                                                    required: true
                                                }
                                            }
                                        },
                                        {
                                            id: {
                                                label: 'label.id'
                                            },
                                            allocationstate: {
                                                label: 'label.allocation.state'
                                            },
                                            dns1: {
                                                label: 'label.dns.1',
                                                isEditable: true,
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            dns2: {
                                                label: 'label.dns.2',
                                                isEditable: true
                                            },
                                            ip6dns1: {
                                                label: 'label.ipv6.dns1',
                                                isEditable: true
                                            },
                                            ip6dns2: {
                                                label: 'label.ipv6.dns2',
                                                isEditable: true
                                            },
                                            internaldns1: {
                                                label: 'label.internal.dns.1',
                                                isEditable: true,
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            internaldns2: {
                                                label: 'label.internal.dns.2',
                                                isEditable: true
                                            },
                                            domainname: {
                                                label: 'label.domain'
                                            },
                                            networktype: {
                                                label: 'label.network.type'
                                            },
                                            guestcidraddress: {
                                                label: 'label.guest.cidr',
                                                isEditable: true
                                            },
                                            domain: {
                                                label: 'label.network.domain',
                                                isEditable: true
                                            },
                                            localstorageenabled: {
                                                label: 'label.local.storage.enabled',
                                                isBoolean: true,
                                                isEditable: true,
                                                converter: cloudStack.converters.toBooleanText
                                            }
                                        },
                                        {
                                            isdedicated: {
                                                label: 'label.dedicated'
                                            },
                                            domainid: {
                                                label: 'label.domain.id'
                                            }
                                        },
                                        {
                                            vmwaredcName: {
                                                label: 'label.vmware.datacenter.name'
                                            },
                                            vmwaredcVcenter: {
                                                label: 'label.vmware.datacenter.vcenter'
                                            },
                                            vmwaredcId: {
                                                label: 'label.vmware.datacenter.id'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: {
                                                    id: args.context.physicalResources[0].id
                                                },
                                                success: function (json) {
                                                    selectedZoneObj = json.listzonesresponse.zone[0];

                                                    $(window).trigger('cloudStack.module.sharedFunctions.addExtraProperties', {
                                                        obj: selectedZoneObj,
                                                        objType: "Zone"
                                                    });

                                                    $.ajax({
                                                        url: createURL('listDedicatedZones'),
                                                        data: {
                                                            zoneid: args.context.physicalResources[0].id
                                                        },
                                                        async: false,
                                                        success: function (json) {
                                                            if (json.listdedicatedzonesresponse.dedicatedzone != undefined) {
                                                                var dedicatedzoneObj = json.listdedicatedzonesresponse.dedicatedzone[0];
                                                                if (dedicatedzoneObj.domainid != null) {
                                                                    $.extend(selectedZoneObj, {
                                                                        isdedicated: 'Yes',
                                                                        domainid: dedicatedzoneObj.domainid,
                                                                        accountid: dedicatedzoneObj.accountid
                                                                    });
                                                                }
                                                            } else {
                                                                $.extend(selectedZoneObj, {
                                                                    isdedicated: 'No',
                                                                    domainid: null,
                                                                    accountid: null
                                                                })
                                                            }
                                                        }
                                                    });

                                                    $.ajax({
                                                        url: createURL('listApis'), //listVmwareDcs API only exists in non-oss bild, so have to check whether it exists before calling it.
                                                        data: {
                                                            name: 'listVmwareDcs'
                                                        },
                                                        async: false,
                                                        success: function (json) {
                                                            $.ajax({
                                                                url: createURL('listVmwareDcs'),
                                                                data: {
                                                                    zoneid: args.context.physicalResources[0].id
                                                                },
                                                                async: false,
                                                                success: function (json) {
                                                                    //e.g. json == { "listvmwaredcsresponse" { "count":1 ,"VMwareDC" [ {"id":"c3c2562d-65e9-4fc7-92e2-773c2efe8f37","zoneid":1,"name":"datacenter","vcenter":"10.10.20.20"} ] } }
                                                                    var vmwaredcs = json.listvmwaredcsresponse.VMwareDC;
                                                                    if (vmwaredcs != null) {
                                                                        selectedZoneObj.vmwaredcName = vmwaredcs[0].name;
                                                                        selectedZoneObj.vmwaredcVcenter = vmwaredcs[0].vcenter;
                                                                        selectedZoneObj.vmwaredcId = vmwaredcs[0].id;
                                                                    }
                                                                }
                                                            });
                                                        },
                                                        error: function (XMLHttpResponse) {
                                                        }
                                                        //override default error handling: cloudStack.dialog.notice({ message: parseXMLHttpResponse(XMLHttpResponse)});
                                                    });

                                                    args.response.success({
                                                        actionFilter: zoneActionfilter,
                                                        data: selectedZoneObj
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    compute: {
                                        title: 'label.compute.and.storage',
                                        custom: cloudStack.uiCustom.systemChart('compute')
                                    },
                                    network: {
                                        title: 'label.physical.network',
                                        custom: cloudStack.uiCustom.systemChart('network')
                                    },
                                    resources: {
                                        title: 'label.resources',
                                        custom: cloudStack.uiCustom.systemChart('resources')
                                    },

                                    systemVMs: {
                                        title: 'label.system.vms',
                                        listView: {
                                            label: 'label.system.vms',
                                            id: 'systemVMs',
                                            fields: {
                                                name: {
                                                    label: 'label.name'
                                                },
                                                systemvmtype: {
                                                    label: 'label.type',
                                                    converter: function (args) {
                                                        if (args == "consoleproxy")
                                                        return "Console Proxy VM"; else if (args == "secondarystoragevm")
                                                        return "Secondary Storage VM"; else
                                                        return args;
                                                    }
                                                },
                                                zonename: {
                                                    label: 'label.zone'
                                                },
                                                state: {
                                                    label: 'label.status',
                                                    converter: function (str) {
                                                        // For localization
                                                        return str;
                                                    },
                                                    indicator: {
                                                        'Running': 'on',
                                                        'Stopped': 'off',
                                                        'Error': 'off',
                                                        'Destroyed': 'off'
                                                    }
                                                }
                                            },
                                            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;
                                                        }
                                                    }
                                                }

                                                var selectedZoneObj = args.context.physicalResources[0];
                                                $.ajax({
                                                    url: createURL("listSystemVms&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                                    dataType: "json",
                                                    async: true,
                                                    success: function (json) {
                                                        var items = json.listsystemvmsresponse.systemvm;
                                                        args.response.success({
                                                            actionFilter: systemvmActionfilter,
                                                            data: items
                                                        });
                                                    }
                                                });
                                            },

                                            detailView: {
                                                noCompact: true,
                                                name: 'label.system.vm.details',
                                                actions: {
                                                    start: {
                                                        label: 'label.action.start.systemvm',
                                                        messages: {
                                                            confirm: function (args) {
                                                                return 'message.action.start.systemvm';
                                                            },
                                                            notification: function (args) {
                                                                return 'label.action.start.systemvm';
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL('startSystemVm&id=' + args.context.systemVMs[0].id),
                                                                dataType: 'json',
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.startsystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId: jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                                            },
                                                                            getActionFilter: function () {
                                                                                return systemvmActionfilter;
                                                                            }
                                                                        }
                                                                    });
                                                                }
                                                            });
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    stop: {
                                                        label: 'label.action.stop.systemvm',
                                                        messages: {
                                                            confirm: function (args) {
                                                                return 'message.action.stop.systemvm';
                                                            },
                                                            notification: function (args) {
                                                                return 'label.action.stop.systemvm';
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL('stopSystemVm&id=' + args.context.systemVMs[0].id),
                                                                dataType: 'json',
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.stopsystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId: jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                                            },
                                                                            getActionFilter: function () {
                                                                                return systemvmActionfilter;
                                                                            }
                                                                        }
                                                                    });
                                                                }
                                                            });
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    restart: {
                                                        label: 'label.action.reboot.systemvm',
                                                        messages: {
                                                            confirm: function (args) {
                                                                return 'message.action.reboot.systemvm';
                                                            },
                                                            notification: function (args) {
                                                                return 'label.action.reboot.systemvm';
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL('rebootSystemVm&id=' + args.context.systemVMs[0].id),
                                                                dataType: 'json',
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.rebootsystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId: jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                                            },
                                                                            getActionFilter: function () {
                                                                                return systemvmActionfilter;
                                                                            }
                                                                        }
                                                                    });
                                                                }
                                                            });
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    remove: {
                                                        label: 'label.action.destroy.systemvm',
                                                        messages: {
                                                            confirm: function (args) {
                                                                return 'message.action.destroy.systemvm';
                                                            },
                                                            notification: function (args) {
                                                                return 'label.action.destroy.systemvm';
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL('destroySystemVm&id=' + args.context.systemVMs[0].id),
                                                                dataType: 'json',
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.destroysystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            getUpdatedItem: function () {
                                                                                return {
                                                                                    state: 'Destroyed'
                                                                                };
                                                                            },
                                                                            jobId: jid
                                                                        }
                                                                    });
                                                                }
                                                            });
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    migrate: {
                                                        label: 'label.action.migrate.systemvm',
                                                        messages: {
                                                            notification: function (args) {
                                                                return 'label.action.migrate.systemvm';
                                                            }
                                                        },
                                                        createForm: {
                                                            title: 'label.action.migrate.systemvm',
                                                            desc: '',
                                                            fields: {
                                                                hostId: {
                                                                    label: 'label.host',
                                                                    validation: {
                                                                        required: true
                                                                    },
                                                                    select: function (args) {
                                                                        $.ajax({
                                                                            url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.systemVMs[0].id),
                                                                            dataType: "json",
                                                                            async: true,
                                                                            success: function (json) {
                                                                                var hostObjs = json.findhostsformigrationresponse.host;
                                                                                var items =[];
                                                                                $(hostObjs).each(function () {
                                                                                    if (this.requiresStorageMotion == false) {
                                                                                        items.push({
                                                                                            id: this.id,
                                                                                            description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                                        });
                                                                                    }
                                                                                });
                                                                                args.response.success({
                                                                                    data: items
                                                                                });
                                                                            }
                                                                        });
                                                                    },
                                                                    error: function (XMLHttpResponse) {
                                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                        args.response.error(errorMsg);
                                                                    }
                                                                }
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.systemVMs[0].id),
                                                                dataType: "json",
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.migratesystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId: jid,
                                                                            getUpdatedItem: function (json) {
                                                                                //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                                $.ajax({
                                                                                    url: createURL("listSystemVms&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                                    dataType: "json",
                                                                                    async: false,
                                                                                    success: function (json) {
                                                                                        var items = json.listsystemvmsresponse.systemvm;
                                                                                        if (items != null && items.length > 0) {
                                                                                            return items[0];
                                                                                        }
                                                                                    }
                                                                                });
                                                                            },
                                                                            getActionFilter: function () {
                                                                                return systemvmActionfilter;
                                                                            }
                                                                        }
                                                                    });
                                                                }
                                                            });
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    diagnostics: {
                                                        label: 'label.action.run.diagnostics',
                                                        messages: {
                                                            notification: function (args) {
                                                                return 'label.action.run.diagnostics';
                                                            },
                                                            complete: function(args) {
                                                                var exitcode = _l('message.diagnostics.exitcode');
                                                                exitcode = exitcode.replace('var', args.exitcode);
                                                                var stderr = _l('message.diagnostics.stderr');
                                                                stderr = stderr.replace('var', args.stderr);
                                                                var stdout = _l('message.diagnostics.stdout');
                                                                stdout = stdout.replace('var', args.stdout);
                                                                var msg = "<div style='text-align: left; overflow-y: auto'>" + exitcode + "<br><br>" + stderr + "<br><br>" + stdout + "</div>";
                                                                return msg;
                                                            }
                                                        },
                                                        createForm: {
                                                            title: 'label.action.run.diagnostics',
                                                            desc: '',
                                                            fields: {
                                                                type: {
                                                                    label: 'label.run.diagnostics.type',
                                                                    validation: {
                                                                        required: true
                                                                    },
                                                                    select: function (args) {
                                                                        var items = [];
                                                                        items.push({
                                                                            id: "ping",
                                                                            description: "Ping"
                                                                        });
                                                                        items.push({
                                                                            id: "traceroute",
                                                                            description: "Traceroute"
                                                                        });
                                                                        items.push({
                                                                            id: "arping",
                                                                            description: "Arping"
                                                                        });
                                                                        args.response.success({
                                                                            data: items
                                                                        });
                                                                    }
                                                                },
                                                                destination: {
                                                                    label: 'label.run.diagnostics.destination',
                                                                    validation: {
                                                                        required: true
                                                                    }
                                                                },
                                                                extra: {
                                                                    label: 'label.run.diagnostics.extra'
                                                                }

                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL("runDiagnostics&targetid=" + args.context.systemVMs[0].id + "&ipaddress=" + args.data.destination + "&type=" + args.data.type + "&params=" + args.data.extra),
                                                                dataType: "json",
                                                                async: true,
                                                                success: function(json) {
                                                                    var jid = json.rundiagnosticsresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId : jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                                            },
                                                                            getActionFilter: function(){
                                                                                return systemvmActionfilter;
                                                                           }
                                                                        }

                                                                    });
                                                                }
                                                            }); //end ajax
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    retrieveDiagnostics: {
                                                        label: 'label.action.get.diagnostics',
                                                        messages: {
                                                            notification: function (args) {
                                                                return 'label.action.get.diagnostics';
                                                            },
                                                            complete: function(args) {
                                                                var url = args.url;
                                                                var htmlMsg = _l('message.download.diagnostics');
                                                                var htmlMsg2 = htmlMsg.replace(/#/, url).replace(/00000/, url);
                                                                return htmlMsg2;
                                                            }
                                                        },
                                                        createForm: {
                                                            title: 'label.action.get.diagnostics',
                                                            desc: '',
                                                            fields: {
                                                                files: {
                                                                    label: 'label.get.diagnostics.files'
                                                                }
                                                            }
                                                        },
                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL("getDiagnosticsData&targetid=" + args.context.systemVMs[0].id + "&files=" + args.data.files),
                                                                dataType: "json",
                                                                async: true,
                                                                success: function(json) {
                                                                    var jid = json.getdiagnosticsdataresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId : jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                                            },
                                                                            getActionFilter: function(){
                                                                                return systemvmActionfilter;
                                                                           }
                                                                        }

                                                                    });
                                                                }
                                                            }); //end ajax
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },

                                                    scaleUp: {
                                                        label: 'label.change.service.offering',
                                                        createForm: {
                                                            title: 'label.change.service.offering',
                                                            desc: function (args) {
                                                                var description = '';
                                                                var vmObj = args.jsonObj;
                                                                //if (vmObj.state == 'Running' && vmObj.hypervisor == 'VMware') { //needs to wait for API fix that will return hypervisor property
                                                                if (vmObj.state == 'Running') {
                                                                    description = 'message.read.admin.guide.scaling.up';
                                                                }
                                                                return description;
                                                            },
                                                            fields: {
                                                                serviceOfferingId: {
                                                                    label: 'label.compute.offering',
                                                                    select: function (args) {
                                                                        var apiCmd = "listServiceOfferings&issystem=true";
                                                                        if (args.context.systemVMs[0].systemvmtype == "secondarystoragevm")
                                                                        apiCmd += "&systemvmtype=secondarystoragevm"; else if (args.context.systemVMs[0].systemvmtype == "consoleproxy")
                                                                        apiCmd += "&systemvmtype=consoleproxy";
                                                                        $.ajax({
                                                                            url: createURL(apiCmd),
                                                                            dataType: "json",
                                                                            async: true,
                                                                            success: function (json) {
                                                                                var serviceofferings = json.listserviceofferingsresponse.serviceoffering;
                                                                                var items =[];
                                                                                $(serviceofferings).each(function () {
                                                                                    if (this.id != args.context.systemVMs[0].serviceofferingid) {
                                                                                        items.push({
                                                                                            id: this.id,
                                                                                            description: this.name
                                                                                        });
                                                                                    }
                                                                                });
                                                                                args.response.success({
                                                                                    data: items
                                                                                });
                                                                            }
                                                                        });
                                                                    }
                                                                }
                                                            }
                                                        },

                                                        action: function (args) {
                                                            $.ajax({
                                                                url: createURL("scaleSystemVm&id=" + args.context.systemVMs[0].id + "&serviceofferingid=" + args.data.serviceOfferingId),
                                                                dataType: "json",
                                                                async: true,
                                                                success: function (json) {
                                                                    var jid = json.changeserviceforsystemvmresponse.jobid;
                                                                    args.response.success({
                                                                        _custom: {
                                                                            jobId: jid,
                                                                            getUpdatedItem: function (json) {
                                                                                return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                                            },
                                                                            getActionFilter: function () {
                                                                                return systemvmActionfilter;
                                                                            }
                                                                        }
                                                                    });
                                                                },
                                                                error: function (json) {
                                                                    args.response.error(parseXMLHttpResponse(json));
                                                                }
                                                            });
                                                        },
                                                        messages: {
                                                            confirm: function (args) {
                                                                return 'message.confirm.scale.up.system.vm';
                                                            },
                                                            notification: function (args) {

                                                                return 'label.system.vm.scaled.up';
                                                            }
                                                        },
                                                        notification: {
                                                            poll: pollAsyncJobResult
                                                        }
                                                    },


                                                    viewConsole: {
                                                        label: 'label.view.console',
                                                        action: {
                                                            externalLink: {
                                                                url: function (args) {
                                                                    return clientConsoleUrl + '?cmd=access&vm=' + args.context.systemVMs[0].id;
                                                                },
                                                                title: function (args) {
                                                                    return args.context.systemVMs[0].id.substr(0, 8);
                                                                    //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                                },
                                                                width: 820,
                                                                height: 640
                                                            }
                                                        }
                                                    }
                                                },
                                                tabs: {
                                                    details: {
                                                        title: 'label.details',
                                                        fields:[ {
                                                            name: {
                                                                label: 'label.name'
                                                            }
                                                        },
                                                        {
                                                            id: {
                                                                label: 'label.id'
                                                            },
                                                            state: {
                                                                label: 'label.state'
                                                            },
                                                            systemvmtype: {
                                                                label: 'label.type',
                                                                converter: function (args) {
                                                                    if (args == "consoleproxy")
                                                                    return 'label.console.proxy.vm'; else if (args == "secondarystoragevm")
                                                                    return 'label.secondary.storage.vm'; else
                                                                    return args;
                                                                }
                                                            },
                                                            zonename: {
                                                                label: 'label.zone'
                                                            },
                                                            publicip: {
                                                                label: 'label.public.ip'
                                                            },
                                                            privateip: {
                                                                label: 'label.private.ip'
                                                            },
                                                            linklocalip: {
                                                                label: 'label.linklocal.ip'
                                                            },
                                                            hostname: {
                                                                label: 'label.host'
                                                            },
                                                            gateway: {
                                                                label: 'label.gateway'
                                                            },
                                                            created: {
                                                                label: 'label.created',
                                                                converter: cloudStack.converters.toLocalDate
                                                            },
                                                            activeviewersessions: {
                                                                label: 'label.active.sessions'
                                                            }
                                                        }],
                                                        dataProvider: function (args) {
                                                            $.ajax({
                                                                url: createURL("listSystemVms&id=" + args.context.systemVMs[0].id),
                                                                dataType: "json",
                                                                async: true,
                                                                success: function (json) {
                                                                    args.response.success({
                                                                        actionFilter: systemvmActionfilter,
                                                                        data: json.listsystemvmsresponse.systemvm[0]
                                                                    });
                                                                }
                                                            });
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    },

                                    // Granular settings for zone
                                    settings: {
                                        title: 'label.settings',
                                        custom: cloudStack.uiCustom.granularSettings({
                                            dataProvider: function (args) {
                                                $.ajax({
                                                    url: createURL('listConfigurations&zoneid=' + args.context.physicalResources[0].id),
                                                    data: listViewDataProvider(args, {
                                                    },
                                                    {
                                                        searchBy: 'name'
                                                    }),
                                                    success: function (json) {
                                                        args.response.success({
                                                            data: json.listconfigurationsresponse.configuration
                                                        });
                                                    },

                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(json));
                                                    }
                                                });
                                            },
                                            actions: {
                                                edit: function (args) {
                                                    // call updateZoneLevelParamter
                                                    var data = {
                                                        name: args.data.jsonObj.name,
                                                        value: args.data.value
                                                    };

                                                    $.ajax({
                                                        url: createURL('updateConfiguration&zoneid=' + args.context.physicalResources[0].id),
                                                        data: data,
                                                        success: function (json) {
                                                            var item = json.updateconfigurationresponse.configuration;
                                                            args.response.success({
                                                                data: item
                                                            });
                                                        },

                                                        error: function (json) {
                                                            args.response.error(parseXMLHttpResponse(json));
                                                        }
                                                    });
                                                }
                                            }
                                        })
                                    }
                                }
                            }
                        },
                        pods: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections.pods.listView, {
                                dataProvider: function (args) {
                                    var data = {
                                    };
                                    listViewDataProvider(args, data);

                                    $.ajax({
                                        url: createURL('listPods'),
                                        data: data,
                                        success: function (json) {
                                            args.response.success({
                                                data: json.listpodsresponse.pod
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },

                                detailView: {
                                    updateContext: function (args) {
                                        var zone;

                                        $.ajax({
                                            url: createURL('listZones'),
                                            data: {
                                                id: args.context.pods[0].zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                zone = json.listzonesresponse.zone[0];
                                            }
                                        });

                                        selectedZoneObj = zone;

                                        return {
                                            zones:[zone]
                                        };
                                    }
                                }
                            });

                            return listView;
                        },
                        clusters: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections.clusters.listView, {
                                dataProvider: function (args) {
                                    var data = {
                                    };
                                    listViewDataProvider(args, data);

                                    $.ajax({
                                        url: createURL('listClusters'),
                                        data: data,
                                        success: function (json) {
                                            args.response.success({
                                                data: json.listclustersresponse.cluster
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },

                                detailView: {
                                    updateContext: function (args) {
                                        var zone;

                                        $.ajax({
                                            url: createURL('listZones'),
                                            data: {
                                                id: args.context.clusters[0].zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                zone = json.listzonesresponse.zone[0];
                                            }
                                        });

                                        selectedZoneObj = zone;

                                        return {
                                            zones:[zone]
                                        };
                                    }
                                }
                            });

                            return listView;
                        },
                        hosts: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections.hosts.listView, {
                                dataProvider: function (args) {
                                    var data = {
                                        type: 'routing'
                                    };
                                    listViewDataProvider(args, data);

                                    $.ajax({
                                        url: createURL('listHosts'),
                                        data: data,
                                        success: function (json) {
                                            var items = json.listhostsresponse.host;
                                            if (items) {
                                                $.each(items, function(idx, host) {
                                                    if (host && host.outofbandmanagement) {
                                                        items[idx].powerstate = host.outofbandmanagement.powerstate;
                                                    }

                                                    if (host && host.hypervisor == "KVM" && host.state == 'Up' && host.details && host.details["secured"] != 'true') {
                                                        items[idx].state = 'Unsecure';
                                                    }

                                                });
                                            }

                                            args.response.success({
                                                data: items
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },

                                detailView: {
                                    updateContext: function (args) {
                                        var zone;

                                        $.ajax({
                                            url: createURL('listZones'),
                                            data: {
                                                id: args.context.hosts[0].zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                zone = json.listzonesresponse.zone[0];
                                            }
                                        });

                                        selectedZoneObj = zone;

                                        return {
                                            zones:[zone]
                                        };
                                    }
                                }
                            });

                            return listView;
                        },
                        primaryStorage: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections[ 'primary-storage'].listView, {
                                dataProvider: function (args) {
                                    var data = {
                                    };
                                    listViewDataProvider(args, data);

                                    $.ajax({
                                        url: createURL('listStoragePools'),
                                        data: data,
                                        success: function (json) {
                                            args.response.success({
                                                data: json.liststoragepoolsresponse.storagepool
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },

                                detailView: {
                                    updateContext: function (args) {
                                        var zone;

                                        $.ajax({
                                            url: createURL('listZones'),
                                            data: {
                                                id: args.context.primarystorages[0].zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                zone = json.listzonesresponse.zone[0];
                                            }
                                        });

                                        selectedZoneObj = zone;

                                        return {
                                            zones:[zone]
                                        };
                                    }
                                }
                            });

                            return listView;
                        },

                        secondaryStorage: function () {
                            var listView = $.extend(
                            true, {
                            },
                            cloudStack.sections.system.subsections[ 'secondary-storage'], {
                                sections: {
                                    secondaryStorage: {
                                        listView: {
                                            dataProvider: function (args) {
                                                var data = {
                                                    type: 'SecondaryStorage'
                                                };
                                                listViewDataProvider(args, data);

                                                $.ajax({
                                                    url: createURL('listImageStores'),
                                                    data: data,
                                                    success: function (json) {
                                                        var items = json.listimagestoresresponse.imagestore;
                                                        if (items != undefined) {
                                                            for (var i = 0; i < items.length; i++) {
                                                                processPropertiesInImagestoreObject(items[i]);
                                                            }
                                                        }
                                                        args.response.success({
                                                            data: items
                                                        });
                                                    },
                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(json));
                                                    }
                                                });
                                            }
                                        }
                                    },
                                    cacheStorage: {
                                        listView: {
                                            dataProvider: function (args) {
                                                var data = {
                                                };
                                                listViewDataProvider(args, data);

                                                $.ajax({
                                                    url: createURL('listSecondaryStagingStores'),
                                                    data: data,
                                                    success: function (json) {
                                                        args.response.success({
                                                            data: json.listsecondarystagingstoreresponse.imagestore
                                                        });
                                                    },
                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(json));
                                                    }
                                                });
                                            }

                                            /*
                                            ,
                                            detailView: {
                                            updateContext: function (args) {
                                            return {
                                            zones: [{}]
                                            };
                                            }
                                            }
                                             */
                                        }
                                    }
                                }
                            });

                            return listView;
                        },
                        systemVms: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections.systemVms.listView, {
                                dataProvider: function (args) {
                                    var data = {
                                    };
                                    listViewDataProvider(args, data);

                                    $.ajax({
                                        url: createURL('listSystemVms'),
                                        data: data,
                                        success: function (json) {
                                            var systemvmObjs = json.listsystemvmsresponse.systemvm || [];
                                            $(systemvmObjs).each(function(idx, item) {
                                                var controlIp = item.linklocalip;
                                                if (item.hypervisor == "VMware") {
                                                    var controlIp = item.privateip;
                                                }
                                                item.controlip = controlIp;
                                            });

                                            args.response.success({
                                                data: systemvmObjs
                                            });
                                        }
                                    });
                                },

                                detailView: {
                                    updateContext: function (args) {
                                        var zone;

                                        $.ajax({
                                            url: createURL('listZones'),
                                            data: {
                                                id: args.context.systemVMs[0].zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                zone = json.listzonesresponse.zone[0];
                                            }
                                        });

                                        selectedZoneObj = zone;

                                        return {
                                            zones:[zone]
                                        };
                                    }
                                }
                            });

                            return listView;
                        },
                        virtualRouters: function () {
                            var listView = $.extend(true, {
                            },
                            cloudStack.sections.system.subsections.virtualRouters, {
                                sections: {
                                    virtualRouterNoGrouping: {
                                        listView: {
                                            dataProvider: function (args) {
                                                var data = {
                                                };
                                                listViewDataProvider(args, data);

                                                var routers =[];

                                                //get account-owned routers
                                                $.ajax({
                                                    url: createURL('listRouters'),
                                                    data: $.extend(data, {
                                                        listAll: true
                                                    }),
                                                    async: false,
                                                    success: function (json) {
                                                        var items = json.listroutersresponse.router ? json.listroutersresponse.router:[];
                                                        $(items).map(function (index, item) {
                                                            routers.push(item);
                                                        });

                                                        //if account is specified in advanced search, don't search project-owned routers
                                                        var accountIsNotSpecifiedInAdvSearch = true;
                                                        if (args.filterBy != null) {
                                                            if (args.filterBy.advSearch != null && typeof(args.filterBy.advSearch) == "object") { //advanced search
                                                                if ('account' in args.filterBy.advSearch  && args.filterBy.advSearch.account.length > 0) {
                                                                    accountIsNotSpecifiedInAdvSearch = false;  //since account and projectid can't be specified together
                                                                }
                                                            }
                                                        }
                                                        if (accountIsNotSpecifiedInAdvSearch) {
                                                            /*
                                                             * In project view, the first listRotuers API(without projectid=-1) will return the same objects as the second listRouters API(with projectid=-1),
                                                             * because in project view, all API calls are appended with projectid=[projectID].
                                                             * Therefore, we only call the second listRouters API(with projectid=-1) in non-project view.
                                                             */
                                                            if (cloudStack.context && cloudStack.context.projects == null) { //non-project view
                                                            $.ajax({
                                                                    url: createURL("listRouters&page=" + args.page + "&pagesize=" + pageSize + "&projectid=-1"),
                                                                async: false,
                                                                success: function (json) {
                                                                    var items = json.listroutersresponse.router ? json.listroutersresponse.router:[];
                                                                    $(items).map(function (index, item) {
                                                                        routers.push(item);
                                                                    });
                                                                }
                                                            });

                                                        }
                                                    }

                                                        args.response.success({
                                                            actionFilter: routerActionfilter,
                                                            data: $(routers).map(mapRouterType)
                                                        });
                                                    }
                                                });

                                                args.response.success({
                                                    actionFilter: routerActionfilter,
                                                    data: $(routers).map(mapRouterType)
                                                });
                                            },

                                            detailView: {
                                                updateContext: function (args) {
                                                    var zone;

                                                    $.ajax({
                                                        url: createURL('listZones'),
                                                        data: {
                                                            id: args.context.routers[0].zoneid
                                                        },
                                                        async: false,
                                                        success: function (json) {
                                                            zone = json.listzonesresponse.zone[0];
                                                        }
                                                    });

                                                    selectedZoneObj = zone;

                                                    return {
                                                        zones:[zone]
                                                    };
                                                }
                                            }
                                        }
                                    }
                                }
                            });

                            return listView;
                        },

                        sockets: function () {
                            var listView = {
                                id: 'sockets',
                                fields: {
                                    hypervisor: {
                                        label: 'label.hypervisor'
                                    },
                                    hosts: {
                                        label: 'label.hosts'
                                    },
                                    sockets: {
                                        label: 'label.sockets'
                                    }
                                },
                                dataProvider: function (args) {
                                    var array1 = [];

                                    // ***** non XenServer (begin) *****
                    var hypervisors = ["Hyperv", "KVM", "VMware", "BareMetal", "LXC", "Ovm3"];

                                            var supportSocketHypervisors = {
                                                "Hyperv": 1,
                                                "KVM": 1,
                                                "VMware": 1,
                                                "Ovm3": 1
                                            };

                                    for (var h = 0; h < hypervisors.length; h++) {
                                                    var totalHostCount = 0;
                                                    var currentPage = 1;
                                                    var returnedHostCount = 0;
                                                    var returnedHostCpusocketsSum = 0;

                                        var callListHostsWithPage = function() {
                                                        $.ajax({
                                                            url: createURL('listHosts'),
                                                            async: false,
                                                            data: {
                                                                type: 'routing',
                                                    hypervisor: hypervisors[h],
                                                                page: currentPage,
                                                                pagesize: pageSize //global variable
                                                            },
                                                            success: function (json) {
                                                                if (json.listhostsresponse.count == undefined) {
                                                                    return;
                                                                }

                                                                    totalHostCount = json.listhostsresponse.count;
                                                                returnedHostCount += json.listhostsresponse.host.length;

                                                                var items = json.listhostsresponse.host;
                                                                for (var i = 0; i < items.length; i++) {
                                                                    if (items[i].cpusockets != undefined && isNaN(items[i].cpusockets) == false) {
                                                                        returnedHostCpusocketsSum += items[i].cpusockets;
                                                                    }
                                                                }

                                                                if (returnedHostCount < totalHostCount) {
                                                                    currentPage++;
                                                        callListHostsWithPage();
                                                                }
                                                            }
                                                        });
                                                    }

                                        callListHostsWithPage();

                                        if ((hypervisors[h] in supportSocketHypervisors) == false) {
                                                        returnedHostCpusocketsSum = 'N/A';
                                                    }

                                        var hypervisorName = hypervisors[h];
                                        if (hypervisorName == "Hyperv") {
                                            hypervisorName = "Hyper-V";
                                        }

                                        array1.push({
                                            hypervisor: hypervisorName,
                                                        hosts: totalHostCount,
                                                        sockets: returnedHostCpusocketsSum
                                            });
                                        }
                                    // ***** non XenServer (end) *****


                                    // ***** XenServer (begin) *****
                                    var totalHostCount = 0;
                                    var currentPage = 1;
                                    var returnedHostCount = 0;

                                    var returnedHostCountForXenServer700 = 0;  //'XenServer 7.0.0'
                                    var returnedHostCpusocketsSumForXenServer700 = 0;

                                    var returnedHostCountForXenServer650 = 0;  //'XenServer 6.5.0'
                                    var returnedHostCpusocketsSumForXenServer650 = 0;

                                    var returnedHostCountForXenServer620 = 0;  //'XenServer 6.2.0'
                                    var returnedHostCpusocketsSumForXenServer620 = 0;

                                    var returnedHostCountForXenServer61x = 0;  //'XenServer 6.1.x and before'

                                    var callListHostsWithPage = function() {
                                        $.ajax({
                                            url: createURL('listHosts'),
                                            async: false,
                                            data: {
                                                type: 'routing',
                                                hypervisor: 'XenServer',
                                                page: currentPage,
                                                pagesize: pageSize //global variable
                                            },
                                            success: function(json) {
                                                if (json.listhostsresponse.count == undefined) {
                                                    return;
                                                }

                                                totalHostCount = json.listhostsresponse.count;
                                                returnedHostCount += json.listhostsresponse.host.length;

                                                var items = json.listhostsresponse.host;
                                                for (var i = 0; i < items.length; i++) {
                                                    if (items[i].hypervisorversion == "7.0.0") {
                                                        returnedHostCountForXenServer700 ++;
                                                        if (items[i].cpusockets != undefined && isNaN(items[i].cpusockets) == false) {
                                                            returnedHostCpusocketsSumForXenServer700 += items[i].cpusockets;
                                                        }
													} else if (items[i].hypervisorversion == "6.5.0") {
                                                        returnedHostCountForXenServer650 ++;
                                                        if (items[i].cpusockets != undefined && isNaN(items[i].cpusockets) == false) {
                                                            returnedHostCpusocketsSumForXenServer650 += items[i].cpusockets;
                                                        }
                                                    } else if (items[i].hypervisorversion == "6.2.0") {
                                                        returnedHostCountForXenServer620 ++;
                                                        if (items[i].cpusockets != undefined && isNaN(items[i].cpusockets) == false) {
                                                            returnedHostCpusocketsSumForXenServer620 += items[i].cpusockets;
                                                        }
                                                    } else {
                                                        returnedHostCountForXenServer61x++;
                                                    }
                                                }

                                                if (returnedHostCount < totalHostCount) {
                                                    currentPage++;
                                                    callListHostsWithPage();
                                                }
                                            }
                                        });
                                    }

                                    callListHostsWithPage();

                                    array1.push({
                                        hypervisor: 'XenServer 7.0.0',
                                        hosts: returnedHostCountForXenServer700,
                                        sockets: returnedHostCpusocketsSumForXenServer700
                                    });

                                    array1.push({
                                        hypervisor: 'XenServer 6.5.0',
                                        hosts: returnedHostCountForXenServer650,
                                        sockets: returnedHostCpusocketsSumForXenServer650
                                    });

                                    array1.push({
                                        hypervisor: 'XenServer 6.2.0',
                                        hosts: returnedHostCountForXenServer620,
                                        sockets: returnedHostCpusocketsSumForXenServer620
                                    });

                                    array1.push({
                                        hypervisor: 'XenServer 6.1.x and before',
                                        hosts: returnedHostCountForXenServer61x,
                                        sockets: 'N/A'
                                    });

                                    // ***** XenServer (end) *****


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

                                }
                            };

                            return listView;
                        },

                        managementServers: function () {
                            var listView = {
                                id: 'managementservers',
                                fields: {
                                    name: {
                                        label: 'label.name'
                                    },
                                    id: {
                                        label: 'label.uuid'
                                    },
                                    state: {
                                        label: 'label.state',
                                        indicator: {
                                            'Up': 'on',
                                            'Down': 'off'
                                        }
                                    },
                                    version: {
                                        label: 'label.version'
                                    }
                                },
                                dataProvider: function (args) {
                                        $.ajax({
                                            url: createURL('listManagementServers'),
                                            async: false,
                                            success: function (json) {
                                                args.response.success({ data: json.listmanagementserversresponse.managementserver });
                                            }
                                        });
                                    }
                                };
                            return listView;
                        }
                    }
                }
            }
        },
        subsections: {
            virtualRouters: {
                sectionSelect: {
                    label: 'label.select-view',
                    preFilter: function(args) {
                        //Only clicking ViewAll Link("view all Virtual Routers") in "Virtual Routers group by XXXXXXX" detailView will have "routerGroupByXXXXXXX" included in args.context
                        if ("routerGroupByZone" in args.context) {
                            return ["routerGroupByZone"]; // read-only (i.e. text "group by Zone")
                        } else if ( "routerGroupByPod" in args.context) {
                            return ["routerGroupByPod"]; // read-only (i.e. text "group by Pod")
                        } else if ("routerGroupByCluster" in args.context) {
                            return ["routerGroupByCluster"]; // read-only (i.e. text "group by Cluster")
                        } else if ("routerGroupByAccount" in args.context) {
                            return ["routerGroupByAccount"]; // read-only (i.e. text "group by Account")
                        } else {
                            return ["routerNoGroup", "routerGroupByZone", "routerGroupByPod", "routerGroupByCluster", "routerGroupByAccount"]; //editable dropdown
                        }
                    }
                },
                sections: {
                    routerNoGroup: {
                        id: 'routers',
                        type: 'select',
                        title: 'label.no.grouping',
                        listView: {
                            id: 'routers',
                            label: 'label.virtual.appliances',
                            horizontalOverflow: true,
                            fields: {
                                name: {
                                    label: 'label.name'
                                },
                                publicip: {
                                    label: 'label.ip'
                                },
                                routerType: {
                                    label: 'label.type'
                                },
                                guestnetworkname: {
                                    label: 'label.network'
                                },
                                account: {
                                    label: 'label.account'
                                },
                                hostname: {
                                    label: 'label.host'
                                },
                                state: {
                                    converter: function (str) {
                                        // For localization
                                        return str;
                                    },
                                    label: 'label.status',
                                    indicator: {
                                        'Running': 'on',
                                        'Stopped': 'off',
                                        'Error': 'off',
                                        'Alert': 'warning'
                                    }
                                },
                                healthchecksfailed: {
                                    converter: function (str) {
                                        if (str) return 'Failed'
                                        return 'Passed';
                                    },
                                    label: 'label.health.check',
                                    indicator: {
                                        false: 'on',
                                        true: 'warning'
                                    }
                                },
                                requiresupgrade: {
                                    label: 'label.requires.upgrade',
                                    converter: cloudStack.converters.toBooleanText
                                }
                            },
                            preFilter: function () {
                                if (!g_routerHealthChecksEnabled) {
                                    return ['healthchecksfailed']
                                }
                                return []
                            },
                            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;
                                        }
                                    }
                                }

                                var data2 = {
                                    // forvpc: false
                                };

                                if (args.context != undefined) {
                                    if ("routerGroupByZone" in args.context) {
                                        $.extend(data2, {
                                            zoneid: args.context.routerGroupByZone[0].id
                                        })
                                    } else if ("routerGroupByPod" in args.context) {
                                        $.extend(data2, {
                                            podid: args.context.routerGroupByPod[0].id
                                        })
                                    } else if ("routerGroupByCluster" in args.context) {
                                        $.extend(data2, {
                                            clusterid: args.context.routerGroupByCluster[0].id
                                        })
                                    } else if ("routerGroupByAccount" in args.context) {
                                        $.extend(data2, {
                                             account: args.context.routerGroupByAccount[0].name,
                                             domainid: args.context.routerGroupByAccount[0].domainid
                                        })
                                    }
                                    if ("networks" in args.context) {
                                       $.extend(data2, {
                                             networkid: args.context.networks[0].id
                                       })
                                    }
                                    if ("vpc" in args.context) {
                                       $.extend(data2, {
                                             vpcid: args.context.vpc[0].id
                                       })
                                    }
                                }

                                var routers =[];
                                $.ajax({
                                    url: createURL("listRouters&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    data: data2,
                                    success: function (json) {
                                        var items = json.listroutersresponse.router ?
                                        json.listroutersresponse.router:[];

                                        $(items).map(function (index, item) {
                                            routers.push(item);
                                        });

                                        /*
                                         * In project view, the first listRotuers API(without projectid=-1) will return the same objects as the second listRouters API(with projectid=-1),
                                         * because in project view, all API calls are appended with projectid=[projectID].
                                         * Therefore, we only call the second listRouters API(with projectid=-1) in non-project view.
                                         */
                                        if (cloudStack.context && cloudStack.context.projects == null) { //non-project view
                                            /*
                                             * account parameter(account+domainid) and project parameter(projectid) are not allowed to be passed together to listXXXXXXX API.
                                             * So, remove account parameter(account+domainid) from data2
                                             */
                                            if ("account" in data2) {
                                                delete data2.account;
                                            }
                                            if ("domainid" in data2) {
                                                delete data2.domainid;
                                            }

                                            $.ajax({
                                                url: createURL("listRouters&page=" + args.page + "&pagesize=" + pageSize + array1.join("") + "&projectid=-1"),
                                                data: data2,
                                                async: false,
                                                success: function (json) {
                                                    var items = json.listroutersresponse.router ?
                                                    json.listroutersresponse.router:[];

                                                    var items = json.listroutersresponse.router ?
                                                    json.listroutersresponse.router:[];

                                                    $(items).map(function (index, item) {
                                                        routers.push(item);
                                                    });
                                                }
                                            });
                                        }

                                        args.response.success({
                                            actionFilter: routerActionfilter,
                                            data: $(routers).map(mapRouterType)
                                        });
                                    }
                                });
                            },
                            detailView: {
                                name: 'label.virtual.appliance.details',
                                viewAll: [{
                                    label: 'label.account',
                                    path: 'accounts',
                                    preFilter: function(args) {
                                        if (args.context.routers[0].projectid)
                                            return false;
                                        if (args.context.routers[0].account == 'system')
                                            return false;
                                        return true;
                                    }
                                }, {
                                    label: 'label.networks',
                                    path: 'network',
                                }, {
                                    label: 'label.instances',
                                    path: 'instances'
                                }],
                                actions: {
                                    start: {
                                        label: 'label.action.start.router',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.start.router';
                                            },
                                            notification: function (args) {
                                                return 'label.action.start.router';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('startRouter&id=' + args.context.routers[0].id),
                                                dataType: 'json',
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.startrouterresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.router;
                                                            },
                                                            getActionFilter: function () {
                                                                return routerActionfilter;
                                                            }
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    stop: {
                                        label: 'label.action.stop.router',
                                        createForm: {
                                            title: 'label.action.stop.router',
                                            desc: 'message.action.stop.router',
                                            fields: {
                                                forced: {
                                                    label: 'force.stop',
                                                    isBoolean: true,
                                                    isChecked: false
                                                }
                                            }
                                        },
                                        messages: {
                                            notification: function (args) {
                                                return 'label.action.stop.router';
                                            }
                                        },
                                        action: function (args) {
                                            var array1 =[];
                                            array1.push("&forced=" + (args.data.forced == "on"));
                                            $.ajax({
                                                url: createURL('stopRouter&id=' + args.context.routers[0].id + array1.join("")),
                                                dataType: 'json',
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.stoprouterresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.router;
                                                            },
                                                            getActionFilter: function () {
                                                                return routerActionfilter;
                                                            }
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    upgradeRouterToUseNewerTemplate: {
                                        label: 'label.upgrade.router.newer.template',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.upgrade.router.newer.template';
                                            },
                                            notification: function (args) {
                                                return 'label.upgrade.router.newer.template';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('upgradeRouterTemplate'),
                                                data: {
                                                    id: args.context.routers[0].id
                                                },
                                                success: function (json) {
                                                    var jobs = json.upgraderoutertemplateresponse.asyncjobs;
                                                    if (jobs != undefined) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jobs[0].jobid
                                                            }
                                                        });
                                                    }
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    'remove': {
                                        label: 'label.destroy.router',
                                        messages: {
                                            confirm: function (args) {
                                                if (args && args.context && args.context.routers[0]) {
                                                    if (args.context.routers[0].state == 'Running') {
                                                        return dictionary['message.action.stop.router'] + ' ' + dictionary['message.confirm.destroy.router'];
                                                    }
                                                }
                                                return 'message.confirm.destroy.router';
                                            },
                                            notification: function (args) {
                                                return 'label.destroy.router';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("destroyRouter&id=" + args.context.routers[0].id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.destroyrouterresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    restart: {
                                        label: 'label.action.reboot.router',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.reboot.router';
                                            },
                                            notification: function (args) {
                                                return 'label.action.reboot.router';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('rebootRouter&id=' + args.context.routers[0].id),
                                                dataType: 'json',
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.rebootrouterresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.router;
                                                            },
                                                            getActionFilter: function () {
                                                                return routerActionfilter;
                                                            }
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    migrate: {
                                        label: 'label.action.migrate.router',
                                        createForm: {
                                            title: 'label.action.migrate.router',
                                            desc: '',
                                            fields: {
                                                hostId: {
                                                    label: 'label.host',
                                                    validation: {
                                                        required: true
                                                    },
                                                    select: function (args) {
                                                        $.ajax({
                                                            url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.routers[0].id),
                                                            dataType: "json",
                                                            async: true,
                                                            success: function (json) {
                                                                var hostObjs = json.findhostsformigrationresponse.host;
                                                                var items =[];
                                                                $(hostObjs).each(function () {
                                                                    items.push({
                                                                        id: this.id,
                                                                        description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                    });
                                                                });
                                                                args.response.success({
                                                                    data: items
                                                                });
                                                            }
                                                        });
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        args.response.error(errorMsg);
                                                    }
                                                }
                                            }
                                        },
                                        messages: {
                                            notification: function (args) {
                                                return 'label.action.migrate.router';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.routers[0].id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.migratesystemvmresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getUpdatedItem: function (json) {
                                                                //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                                $.ajax({
                                                                    url: createURL("listRouters&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                                    dataType: "json",
                                                                    async: false,
                                                                    success: function (json) {
                                                                        var items = json.listroutersresponse.router;
                                                                        if (items != null && items.length > 0) {
                                                                            return items[0];
                                                                        }
                                                                    }
                                                                });
                                                            },
                                                            getActionFilter: function () {
                                                                return routerActionfilter;
                                                            }
                                                        }
                                                    });
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    // VR Diagnostics
                                    diagnostics: {
                                        label: 'label.action.run.diagnostics',
                                        messages: {
                                            notification: function (args) {
                                                return 'label.action.run.diagnostics';
                                            },
                                            complete: function(args) {
                                                var exitcode = _l('message.diagnostics.exitcode');
                                                exitcode = exitcode.replace('var', args.exitcode);
                                                var stderr = _l('message.diagnostics.stderr');
                                                stderr = stderr.replace('var', args.stderr);
                                                var stdout = _l('message.diagnostics.stdout');
                                                stdout = stdout.replace('var', args.stdout);
                                                var msg = "<div style='text-align: left; overflow-y: auto'>" + exitcode + "<br><br>" + stderr + "<br><br>" + stdout + "</div>";
                                                return msg;
                                            }
                                        },
                                        createForm: {
                                            title: 'label.action.run.diagnostics',
                                            desc: '',
                                            fields: {
                                                type: {
                                                    label: 'label.run.diagnostics.type',
                                                    validation: {
                                                        required: true
                                                    },
                                                    select: function (args) {
                                                        var items = [];
                                                        items.push({
                                                            id: "ping",
                                                            description: "Ping"
                                                        });
                                                        items.push({
                                                            id: "traceroute",
                                                            description: "Traceroute"
                                                        });
                                                        items.push({
                                                            id: "arping",
                                                            description: "Arping"
                                                        });
                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                },
                                                destination: {
                                                    label: 'label.run.diagnostics.destination',
                                                    validation: {
                                                        required: true
                                                    }
                                                },
                                                extra: {
                                                    label: 'label.run.diagnostics.extra'
                                                }

                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("runDiagnostics&targetid=" + args.context.routers[0].id + "&ipaddress=" + args.data.destination + "&type=" + args.data.type + "&params=" + args.data.extra),
                                                dataType: "json",
                                                async: true,
                                                success: function(json) {
                                                    var jid = json.rundiagnosticsresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId : jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                            },
                                                            getActionFilter: function(){
                                                                return routerActionfilter;
                                                           }
                                                        }

                                                    });
                                                }
                                            }); //end ajax
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    retrieveDiagnostics: {
                                        label: 'label.action.get.diagnostics',
                                        messages: {
                                            notification: function (args) {
                                                return 'label.action.get.diagnostics';
                                            },
                                            complete: function(args) {
                                                var url = args.url;
                                                var htmlMsg = _l('message.download.diagnostics');
                                                var htmlMsg2 = htmlMsg.replace(/#/, url).replace(/00000/, url);
                                                return htmlMsg2;
                                            }
                                        },
                                        createForm: {
                                            title: 'label.action.get.diagnostics',
                                            desc: 'label.get.diagnostics.desc',
                                            fields: {
                                                files: {
                                                    label: 'label.get.diagnostics.files'
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("getDiagnosticsData&targetid=" + args.context.routers[0].id + "&files=" + args.data.files),
                                                dataType: "json",
                                                async: true,
                                                success: function(json) {
                                                    var jid = json.getdiagnosticsdataresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId : jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                            },
                                                            getActionFilter: function(){
                                                                return systemvmActionfilter;
                                                           }
                                                        }

                                                    });
                                                }
                                            }); //end ajax
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },

                                    scaleUp: { //*** Infrastructure > Virtual Routers > change service offering ***
                                        label: 'label.change.service.offering',
                                        createForm: {
                                            title: 'label.change.service.offering',
                                            desc: function (args) {
                                                var description = '';
                                                var vmObj = args.jsonObj;
                                                //if (vmObj.state == 'Running' && vmObj.hypervisor == 'VMware') { //needs to wait for API fix that will return hypervisor property
                                                if (vmObj.state == 'Running') {
                                                    description = 'message.read.admin.guide.scaling.up';
                                                }
                                                return description;
                                            },
                                            fields: {
                                                serviceOfferingId: {
                                                    label: 'label.compute.offering',
                                                    select: function (args) {
                                                        $.ajax({
                                                            url: createURL('listServiceOfferings'),
                                                            data: {
                                                                issystem: true,
                                                                systemvmtype: 'domainrouter',
                                                                virtualmachineid: args.context.routers[0].id
                                                            },
                                                            success: function (json) {
                                                                var serviceofferings = json.listserviceofferingsresponse.serviceoffering;
                                                                var items =[];
                                                                $(serviceofferings).each(function () {
                                                                    // if(this.id != args.context.routers[0].serviceofferingid) {
                                                                    items.push({
                                                                        id: this.id,
                                                                        description: this.name
                                                                    });
                                                                    //default one (i.e. "System Offering For Software Router") doesn't have displaytext property. So, got to use name property instead.
                                                                });
                                                                args.response.success({
                                                                    data: items
                                                                });
                                                            }
                                                        });
                                                    }
                                                }
                                            }
                                        },

                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("scaleSystemVm&id=" + args.context.routers[0].id + "&serviceofferingid=" + args.data.serviceOfferingId),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var jid = json.changeserviceforsystemvmresponse.jobid;
                                                    args.response.success({
                                                        _custom: {
                                                            jobId: jid,
                                                            getUpdatedItem: function (json) {
                                                                return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                            },
                                                            getActionFilter: function () {
                                                                return routerActionfilter;
                                                            }
                                                        }
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        },
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.scale.up.router.vm';
                                            },
                                            notification: function (args) {

                                                return 'label.router.vm.scaled.up';
                                            }
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    },


                                    viewConsole: {
                                        label: 'label.view.console',
                                        action: {
                                            externalLink: {
                                                url: function (args) {
                                                    return clientConsoleUrl + '?cmd=access&vm=' + args.context.routers[0].id;
                                                },
                                                title: function (args) {
                                                    return args.context.routers[0].id.substr(0, 8);
                                                    //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                                },
                                                width: 820,
                                                height: 640
                                            }
                                        }
                                    },

                                    healthChecks: {
                                        label: 'label.action.router.health.checks',
                                        createForm: {
                                            title: 'label.action.router.health.checks',
                                            desc: 'message.action.router.health.checks',
                                            fields: {
                                                performfreshchecks: {
                                                    label: 'label.perform.fresh.checks',
                                                    isBoolean: true
                                                }
                                            }
                                        },
                                        action: function (args) {
                                            if (!g_routerHealthChecksEnabled) {
                                                cloudStack.dialog.notice({
                                                    message: 'Router health checks are disabled. Please enable router.health.checks.enabled to execute this action'
                                                })
                                                args.response.success()
                                                return
                                            }
                                            var data = {
                                                'routerid': args.context.routers[0].id,
                                                'performfreshchecks': (args.data.performfreshchecks === 'on')
                                            };
                                            $.ajax({
                                                url: createURL('getRouterHealthCheckResults'),
                                                dataType: 'json',
                                                data: data,
                                                async: true,
                                                success: function (json) {
                                                    var healthChecks = json.getrouterhealthcheckresultsresponse.routerhealthchecks.healthchecks
                                                    var numChecks = healthChecks.length
                                                    var failedChecks = 0
                                                    $.each(healthChecks, function(idx, check) {
                                                        if (!check.success) failedChecks = failedChecks + 1
                                                    })
                                                    cloudStack.dialog.notice({
                                                        message: 'Found ' + numChecks + ' checks for router, with ' + failedChecks + ' failing checks. Please visit router > Health Checks tab to see details'
                                                    })
                                                    args.response.success();
                                                }
                                            });
                                        },
                                        messages: {
                                            notification: function(args) {
                                                return 'label.action.router.health.checks'
                                            }
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.details',
                                        preFilter: function (args) {
                                            var hiddenFields =[];
                                            if (! args.context.routers[0].project) {
                                                hiddenFields.push('project');
                                                hiddenFields.push('projectid');
                                            }
                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: {
                                                    id: args.context.routers[0].zoneid
                                                },
                                                async: false,
                                                success: function (json) {
                                                    if (json.listzonesresponse.zone != undefined) {
                                                        var zoneObj = json.listzonesresponse.zone[0];
                                                        if (zoneObj.networktype == 'Basic') {
                                                            hiddenFields.push('publicip');
                                                            //In Basic zone, guest IP is public IP. So, publicip is not returned by listRouters API. Only guestipaddress is returned by listRouters API.
                                                        }
                                                    }
                                                }
                                            });

                                            if ('routers' in args.context && args.context.routers[0].vpcid != undefined) {
                                                hiddenFields.push('guestnetworkid');
                                                hiddenFields.push('guestnetworkname');
                                            } else if ('routers' in args.context && args.context.routers[0].guestnetworkid != undefined) {
                                                hiddenFields.push('vpcid');
                                                hiddenFields.push('vpcname');
                                            }

                                            return hiddenFields;
                                        },
                                        fields:[ {
                                            name: {
                                                label: 'label.name'
                                            },
                                            project: {
                                                label: 'label.project'
                                            }
                                        },
                                        {
                                            id: {
                                                label: 'label.id'
                                            },
                                            projectid: {
                                                label: 'label.project.id'
                                            },
                                            state: {
                                                label: 'label.state'
                                            },
                                            version: {
                                                label: 'label.version'
                                            },
                                            requiresupgrade: {
                                                label: 'label.requires.upgrade',
                                                converter: cloudStack.converters.toBooleanText
                                            },
                                            guestnetworkid: {
                                                label: 'label.network.id'
                                            },
                                            guestnetworkname: {
                                                label: 'label.network.name'
                                            },
                                            vpcid: {
                                                label: 'label.vpc.id'
                                            },
                                            vpcname: {
                                                label: 'label.vpc'
                                            },
                                            publicip: {
                                                label: 'label.public.ip'
                                            },
                                            guestipaddress: {
                                                label: 'label.guest.ip'
                                            },
                                            linklocalip: {
                                                label: 'label.linklocal.ip'
                                            },
                                            hostname: {
                                                label: 'label.host'
                                            },
                                            serviceofferingname: {
                                                label: 'label.compute.offering'
                                            },
                                            networkdomain: {
                                                label: 'label.network.domain'
                                            },
                                            domain: {
                                                label: 'label.domain'
                                            },
                                            account: {
                                                label: 'label.account'
                                            },
                                            created: {
                                                label: 'label.created',
                                                converter: cloudStack.converters.toLocalDate
                                            },
                                            isredundantrouter: {
                                                label: 'label.redundant.router',
                                                converter: cloudStack.converters.toBooleanText
                                            },
                                            redundantRouterState: {
                                                label: 'label.redundant.state'
                                            },
                                            vpcid: {
                                                label: 'label.vpc.id'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                dataType: 'json',
                                                async: true,
                                                success: function (json) {
                                                    var jsonObj = json.listroutersresponse.router[0];
                                                    addExtraPropertiesToRouterInstanceObject(jsonObj);
                                                    args.response.success({
                                                        actionFilter: routerActionfilter,
                                                        data: jsonObj
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    nics: {
                                        title: 'label.nics',
                                        multiple: true,
                                        fields:[ {
                                            name: {
                                                label: 'label.name',
                                                header: true
                                            },
                                            type: {
                                                label: 'label.type'
                                            },
                                            traffictype: {
                                                label: 'label.traffic.type'
                                            },
                                            networkname: {
                                                label: 'label.network.name'
                                            },
                                            netmask: {
                                                label: 'label.netmask'
                                            },
                                            ipaddress: {
                                                label: 'label.ip.address'
                                            },
                                            id: {
                                                label: 'label.id'
                                            },
                                            networkid: {
                                                label: 'label.network.id'
                                            },
                                            isolationuri: {
                                                label: 'label.isolation.uri'
                                            },
                                            broadcasturi: {
                                                label: 'label.broadcast.uri'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL("listRouters&id=" + args.context.routers[0].id),
                                                dataType: 'json',
                                                async: true,
                                                success: function (json) {
                                                    var jsonObj = json.listroutersresponse.router[0].nic;

                                                    args.response.success({
                                                        actionFilter: routerActionfilter,
                                                        data: $.map(jsonObj, function (nic, index) {
                                                            var name = 'NIC ' + (index + 1);
                                                            if (nic.isdefault) {
                                                                name += ' (' + _l('label.default') + ')';
                                                            }
                                                            return $.extend(nic, {
                                                                name: name
                                                            });
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    healthCheckResults: {
                                        title: 'label.router.health.checks',
                                        listView: {
                                            id: 'routerHealthCheckResults',
                                            label: 'label.router.health.checks',
                                            hideToolbar: true,
                                            fields: {
                                                checkname: {
                                                    label: 'label.router.health.check.name'
                                                },
                                                checktype: {
                                                    label: 'label.router.health.check.type'
                                                },
                                                success: {
                                                    label: 'label.router.health.check.success',
                                                    converter: function (args) {
                                                        if (args) {
                                                            return _l('True');
                                                        } else {
                                                            return _l('False');
                                                        }
                                                    },
                                                    indicator: {
                                                        true: 'on',
                                                        false: 'off'
                                                    }
                                                },
                                                lastupdated: {
                                                    label: 'label.router.health.check.last.updated'
                                                }
                                            },
                                            actions: {
                                                details: {
                                                    label: 'label.router.health.check.details',
                                                    action: {
                                                        custom: function (args) {
                                                            cloudStack.dialog.notice({
                                                                message: args.context.routerHealthCheckResults[0].details
                                                            })
                                                        }
                                                    }
                                                }
                                            },
                                            dataProvider: function(args) {
                                                if (!g_routerHealthChecksEnabled) {
                                                    cloudStack.dialog.notice({
                                                        message: 'Router health checks are disabled. Please enable router.health.checks.enabled to get data'
                                                    })
                                                    args.response.success({})
                                                    return
                                                }
                                                if (args.page > 1) {
                                                    // Only one page is supported as it's not list command.
                                                    args.response.success({});
                                                    return
                                                }

                                                $.ajax({
                                                    url: createURL('getRouterHealthCheckResults'),
                                                    data: {
                                                        'routerid': args.context.routers[0].id
                                                    },
                                                    success: function (json) {
                                                        var hcData = json.getrouterhealthcheckresultsresponse.routerhealthchecks.healthchecks
                                                        args.response.success({
                                                            data: hcData
                                                        });
                                                    }
                                                });
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    routerGroupByZone: {
                        id: 'routerGroupByZone',
                        type: 'select',
                        title: 'label.group.by.zone',
                        listView: {
                            id: 'routerGroupByZone',
                            label: 'label.virtual.appliances',
                            fields: {
                                name: {
                                    label: 'label.zone'
                                },
                                routerCount: {
                                    label: 'label.total.virtual.routers'
                                },
                                routerRequiresUpgrade: {
                                    label: 'label.upgrade.required',
                                    converter: function (args) {
                                        if (args > 0) {
                                            return _l('label.yes');
                                        } else {
                                            return _l('label.no');
                                        }
                                    }
                                }
                            },

                            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("listZones&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        var groupbyObjs = json.listzonesresponse.zone;
                                        if (groupbyObjs != null) {
                                            addExtraPropertiesToGroupbyObjects(groupbyObjs, 'zoneid');
                                        }
                                        args.response.success({
                                            data: groupbyObjs
                                        });
                                    }
                                });
                            },
                            detailView: {
                                name: 'label.virtual.routers.group.zone',
                                viewAll: {
                                    path: '_zone.virtualRouters',
                                    label: 'label.virtual.appliances'
                                },
                                actions: {
                                    upgradeRouterToUseNewerTemplate: {
                                        label: 'label.upgrade.router.newer.template',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.upgrade.routers.newtemplate';
                                            },
                                            notification: function (args) {
                                                return 'label.upgrade.router.newer.template';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('upgradeRouterTemplate'),
                                                data: {
                                                    zoneid: args.context.routerGroupByZone[0].id
                                                },
                                                success: function (json) {
                                                    var jobs = json.upgraderoutertemplateresponse.asyncjobs;
                                                    if (jobs != undefined) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jobs[0].jobid
                                                            }
                                                        });
                                                    }
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.virtual.routers.group.zone',
                                        fields:[ {
                                            name: {
                                                label: 'label.zone'
                                            }
                                        },
                                        {
                                            routerCount: {
                                                label: 'label.total.virtual.routers'
                                            },
                                            routerRequiresUpgrade: {
                                                label: 'label.upgrade.required',
                                                converter: function (args) {
                                                    if (args > 0) {
                                                        return _l('label.yes');
                                                    } else {
                                                        return _l('label.no');
                                                    }
                                                }
                                            },
                                            numberOfRouterRequiresUpgrade: {
                                                label: 'label.total.virtual.routers.upgrade'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            addExtraPropertiesToGroupbyObject(args.context.routerGroupByZone[0], 'zoneid');
                                            args.response.success({
                                                data: args.context.routerGroupByZone[0],
                                                actionFilter: routerGroupActionfilter
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    },
                    routerGroupByPod: {
                        id: 'routerGroupByPod',
                        type: 'select',
                        title: 'label.group.by.pod',
                        listView: {
                            id: 'routerGroupByPod',
                            label: 'label.virtual.appliances',
                            fields: {
                                name: {
                                    label: 'label.pod'
                                },
                                routerCount: {
                                    label: 'label.total.virtual.routers'
                                },
                                routerRequiresUpgrade: {
                                    label: 'label.upgrade.required',
                                    converter: function (args) {
                                        if (args > 0) {
                                            return _l('label.yes');
                                        } else {
                                            return _l('label.no');
                                        }
                                    }
                                }
                            },

                            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&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        var groupbyObjs = json.listpodsresponse.pod;
                                        if (groupbyObjs != null) {
                                            addExtraPropertiesToGroupbyObjects(groupbyObjs, 'podid');
                                        }
                                        args.response.success({
                                            data: groupbyObjs
                                        });
                                    }
                                });
                            },
                            detailView: {
                                name: 'label.virtual.routers.group.pod',
                                viewAll: {
                                    path: '_zone.virtualRouters',
                                    label: 'label.virtual.appliances'
                                },
                                actions: {
                                    upgradeRouterToUseNewerTemplate: {
                                        label: 'label.upgrade.router.newer.template',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.upgrade.routers.pod.newtemplate';
                                            },
                                            notification: function (args) {
                                                return 'label.upgrade.router.newer.template';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('upgradeRouterTemplate'),
                                                data: {
                                                    podid: args.context.routerGroupByPod[0].id
                                                },
                                                success: function (json) {
                                                    var jobs = json.upgraderoutertemplateresponse.asyncjobs;
                                                    if (jobs != undefined) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jobs[0].jobid
                                                            }
                                                        });
                                                    }
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.virtual.routers.group.pod',
                                        fields:[ {
                                            name: {
                                                label: 'label.pod'
                                            }
                                        },
                                        {
                                            routerCount: {
                                                label: 'label.total.virtual.routers'
                                            },
                                            routerRequiresUpgrade: {
                                                label: 'label.upgrade.required',
                                                converter: function (args) {
                                                    if (args > 0) {
                                                        return _l('label.yes');
                                                    } else {
                                                        return _l('label.no');
                                                    }
                                                }
                                            },
                                            numberOfRouterRequiresUpgrade: {
                                                label: 'label.total.virtual.routers.upgrade'
                                            },
                                            zonename: {
                                                label: 'label.zone'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            addExtraPropertiesToGroupbyObject(args.context.routerGroupByPod[0], 'podid');
                                            args.response.success({
                                                data: args.context.routerGroupByPod[0],
                                                actionFilter: routerGroupActionfilter
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    },
                    routerGroupByCluster: {
                        id: 'routerGroupByCluster',
                        type: 'select',
                        title: 'label.group.by.cluster',
                        listView: {
                            id: 'routerGroupByCluster',
                            label: 'label.virtual.appliances',
                            fields: {
                                name: {
                                    label: 'label.cluster'
                                },
                                routerCount: {
                                    label: 'label.total.virtual.routers'
                                },
                                routerRequiresUpgrade: {
                                    label: 'label.upgrade.required',
                                    converter: function (args) {
                                        if (args > 0) {
                                            return _l('label.yes');
                                        } else {
                                            return _l('label.no');
                                        }
                                    }
                                }
                            },

                            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("listClusters&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        var groupbyObjs = json.listclustersresponse.cluster;
                                        if (groupbyObjs != null) {
                                            addExtraPropertiesToGroupbyObjects(groupbyObjs, 'clusterid');
                                        }
                                        args.response.success({
                                            data: groupbyObjs
                                        });
                                    }
                                });
                            },
                            detailView: {
                                name: 'label.virtual.routers.group.cluster',
                                viewAll: {
                                    path: '_zone.virtualRouters',
                                    label: 'label.virtual.appliances'
                                },
                                actions: {
                                    upgradeRouterToUseNewerTemplate: {
                                        label: 'label.upgrade.router.newer.template',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.upgrade.routers.cluster.newtemplate';
                                            },
                                            notification: function (args) {
                                                return 'label.upgrade.router.newer.template';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('upgradeRouterTemplate'),
                                                data: {
                                                    clusterid: args.context.routerGroupByCluster[0].id
                                                },
                                                success: function (json) {
                                                    var jobs = json.upgraderoutertemplateresponse.asyncjobs;
                                                    if (jobs != undefined) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jobs[0].jobid
                                                            }
                                                        });
                                                    }
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.virtual.routers.group.cluster',
                                        fields:[ {
                                            name: {
                                                label: 'label.cluster'
                                            }
                                        },
                                        {
                                            routerCount: {
                                                label: 'label.total.virtual.routers'
                                            },
                                            routerRequiresUpgrade: {
                                                label: 'label.upgrade.required',
                                                converter: function (args) {
                                                    if (args > 0) {
                                                        return _l('label.yes');
                                                    } else {
                                                        return _l('label.no');
                                                    }
                                                }
                                            },
                                            numberOfRouterRequiresUpgrade: {
                                                label: 'label.total.virtual.routers.upgrade'
                                            },
                                            podname: {
                                                label: 'label.pod'
                                            },
                                            zonename: {
                                                label: 'label.zone.lower'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            addExtraPropertiesToGroupbyObject(args.context.routerGroupByCluster[0], 'clusterid');
                                            args.response.success({
                                                data: args.context.routerGroupByCluster[0],
                                                actionFilter: routerGroupActionfilter
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    },
                    routerGroupByAccount: {
                        id: 'routerGroupByAccount',
                        type: 'select',
                        title: 'label.group.by.account',
                        listView: {
                            id: 'routerGroupByAccount',
                            label: 'label.virtual.appliances',
                            fields: {
                                name: {
                                    label: 'label.account'
                                },
                                domain: {
                                    label: 'label.domain'
                                },
                                routerCount: {
                                    label: 'label.total.virtual.routers'
                                },
                                routerRequiresUpgrade: {
                                    label: 'label.upgrade.required',
                                    converter: function (args) {
                                        if (args > 0) {
                                            return _l('label.yes');
                                        } else {
                                            return _l('label.no');
                                        }
                                    }
                                }
                            },

                            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("listAccounts&listAll=true&details=min&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    success: function (json) {
                                        var accountObjs = json.listaccountsresponse.account;
                                        if (accountObjs != null) {
                                            for (var i = 0; i < accountObjs.length; i++) {
                                                var currentPage = 1;
                                                $.ajax({
                                                    url: createURL('listRouters'),
                                                    data: {
                                                        account: accountObjs[i].name,
                                                        domainid: accountObjs[i].domainid,
                                                        listAll: true,
                                                        page: currentPage,
                                                        pagesize: pageSize //global variable
                                                    },
                                                    async: false,
                                                    success: function (json) {
                                                        if (json.listroutersresponse.count != undefined) {
                                                            accountObjs[i].routerCount = json.listroutersresponse.count;
                                                            var routerCountFromAllPages = json.listroutersresponse.count;
                                                            var routerCountFromFirstPageToCurrentPage = json.listroutersresponse.router.length;
                                                            var routerRequiresUpgrade = 0;

                                                            var items = json.listroutersresponse.router;
                                                            for (var k = 0; k < items.length; k++) {
                                                                if (items[k].requiresupgrade) {
                                                                    routerRequiresUpgrade++;
                                                                }
                                                            }

                                                            var callListApiWithPage = function () {
                                                                $.ajax({
                                                                    url: createURL('listRouters'),
                                                                    async: false,
                                                                    data: {
                                                                        account: accountObjs[i].name,
                                                                        domainid: accountObjs[i].domainid,
                                                                        listAll: true,
                                                                        page: currentPage,
                                                                        pagesize: pageSize //global variable
                                                                    },
                                                                    success: function (json) {
                                                                        routerCountFromFirstPageToCurrentPage += json.listroutersresponse.router.length;
                                                                        var items = json.listroutersresponse.router;
                                                                        for (var k = 0; k < items.length; k++) {
                                                                            if (items[k].requiresupgrade) {
                                                                                routerRequiresUpgrade++;
                                                                            }
                                                                        }
                                                                        if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                                                                            currentPage++;
                                                                            callListApiWithPage();
                                                                        }
                                                                    }
                                                                });
                                                            }
                                                            if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                                                                currentPage++;
                                                                callListApiWithPage();
                                                            }
                                                            accountObjs[i].routerRequiresUpgrade = routerRequiresUpgrade;
                                                        } else {
                                                            accountObjs[i].routerCount = 0;
                                                            accountObjs[i].routerRequiresUpgrade = 0;
                                                        }
                                                    }
                                                });
                                            }
                                        }
                                        args.response.success({
                                            data: accountObjs
                                        });
                                    }
                                });
                            },
                            detailView: {
                                name: 'label.virtual.routers.group.account',
                                viewAll: {
                                    path: '_zone.virtualRouters',
                                    label: 'label.virtual.appliances'
                                },
                                actions: {
                                    upgradeRouterToUseNewerTemplate: {
                                        label: 'label.upgrade.router.newer.template',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.upgrade.routers.account.newtemplate';
                                            },
                                            notification: function (args) {
                                                return 'label.upgrade.router.newer.template';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL('upgradeRouterTemplate'),
                                                data: {
                                                    account: args.context.routerGroupByAccount[0].name,
                                                    domainid: args.context.routerGroupByAccount[0].domainid
                                                },
                                                success: function (json) {
                                                    var jobs = json.upgraderoutertemplateresponse.asyncjobs;
                                                    if (jobs != undefined) {
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jobs[0].jobid
                                                            }
                                                        });
                                                    }
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: pollAsyncJobResult
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.virtual.routers.group.account',
                                        fields:[ {
                                            name: {
                                                label: 'label.account'
                                            },
                                            domain: {
                                                label: 'label.domain'
                                            }
                                        },
                                        {
                                            routerCount: {
                                                label: 'label.total.virtual.routers'
                                            },
                                            routerRequiresUpgrade: {
                                                label: 'label.upgrade.required',
                                                converter: function (args) {
                                                    if (args > 0) {
                                                        return _l('label.yes');
                                                    } else {
                                                        return _l('label.no');
                                                    }
                                                }
                                            },
                                            numberOfRouterRequiresUpgrade: {
                                                label: 'label.total.virtual.routers.upgrade'
                                            }
                                        }],
                                        dataProvider: function (args) {
                                            var currentPage = 1;
                                            $.ajax({
                                                url: createURL('listRouters'),
                                                data: {
                                                    account: args.context.routerGroupByAccount[0].name,
                                                    domainid: args.context.routerGroupByAccount[0].domainid,
                                                    listAll: true,
                                                    page: currentPage,
                                                    pagesize: pageSize //global variable
                                                },
                                                async: false,
                                                success: function (json) {
                                                    if (json.listroutersresponse.count != undefined) {
                                                        args.context.routerGroupByAccount[0].routerCount = json.listroutersresponse.count;
                                                        var routerCountFromAllPages = json.listroutersresponse.count;
                                                        var routerCountFromFirstPageToCurrentPage = json.listroutersresponse.router.length;
                                                        var routerRequiresUpgrade = 0;

                                                        var items = json.listroutersresponse.router;
                                                        for (var k = 0; k < items.length; k++) {
                                                            if (items[k].requiresupgrade) {
                                                                routerRequiresUpgrade++;
                                                            }
                                                        }

                                                        var callListApiWithPage = function () {
                                                            $.ajax({
                                                                url: createURL('listRouters'),
                                                                async: false,
                                                                data: {
                                                                    account: args.context.routerGroupByAccount[0].name,
                                                                    domainid: args.context.routerGroupByAccount[0].domainid,
                                                                    listAll: true,
                                                                    page: currentPage,
                                                                    pagesize: pageSize //global variable
                                                                },
                                                                success: function (json) {
                                                                    routerCountFromFirstPageToCurrentPage += json.listroutersresponse.router.length;
                                                                    var items = json.listroutersresponse.router;
                                                                    for (var k = 0; k < items.length; k++) {
                                                                        if (items[k].requiresupgrade) {
                                                                            routerRequiresUpgrade++;
                                                                        }
                                                                    }
                                                                    if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                                                                        currentPage++;
                                                                        callListApiWithPage();
                                                                    }
                                                                }
                                                            });
                                                        }
                                                        if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                                                            currentPage++;
                                                            callListApiWithPage();
                                                        }
                                                        args.context.routerGroupByAccount[0].routerRequiresUpgrade = routerRequiresUpgrade;
                                                        args.context.routerGroupByAccount[0].numberOfRouterRequiresUpgrade = routerRequiresUpgrade;
                                                    } else {
                                                        args.context.routerGroupByAccount[0].routerCount = 0;
                                                        args.context.routerGroupByAccount[0].routerRequiresUpgrade = 0;
                                                        args.context.routerGroupByAccount[0].numberOfRouterRequiresUpgrade = 0;
                                                    }
                                                }
                                            });
                                            setTimeout(function () {
                                                args.response.success({
                                                    data: args.context.routerGroupByAccount[0],
                                                    actionFilter: routerGroupActionfilter
                                                });
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            },
            systemVms: {
                listView: {
                    label: 'label.system.vms',
                    id: 'systemVMs',
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        systemvmtype: {
                            label: 'label.type',
                            converter: function (args) {
                                if (args == "consoleproxy")
                                return "Console Proxy VM"; else if (args == "secondarystoragevm")
                                return "Secondary Storage VM"; else
                                return args;
                            }
                        },
                        publicip: {
                            label: 'label.public.ip'
                        },
                        hostname: {
                            label: 'label.host'
                        },
                        zonename: {
                            label: 'label.zone'
                        },
                        state: {
                            label: 'label.vm.state',
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            indicator: {
                                'Running': 'on',
                                'Stopped': 'off',
                                'Error': 'off',
                                'Destroyed': 'off'
                            }
                        },

                        agentstate: {
                            label: 'label.agent.state',
                            indicator: {
                                'Up': 'on',
                                'Down': 'off'
                            }
                        }
                    },
                    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;
                                }
                            }
                        }

                        var selectedZoneObj = args.context.physicalResources[0];
                        $.ajax({
                            url: createURL("listSystemVms&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.listsystemvmsresponse.systemvm;
                                args.response.success({
                                    actionFilter: systemvmActionfilter,
                                    data: items
                                });
                            }
                        });
                    },

                    detailView: {
                        name: 'label.system.vm.details',
                        actions: {
                            start: {
                                label: 'label.action.start.systemvm',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.start.systemvm';
                                    },
                                    notification: function (args) {
                                        return 'label.action.start.systemvm';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL('startSystemVm&id=' + args.context.systemVMs[0].id),
                                        dataType: 'json',
                                        async: true,
                                        success: function (json) {
                                            var jid = json.startsystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                    },
                                                    getActionFilter: function () {
                                                        return systemvmActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            stop: {
                                label: 'label.action.stop.systemvm',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.stop.systemvm';
                                    },
                                    notification: function (args) {
                                        return 'label.action.stop.systemvm';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL('stopSystemVm&id=' + args.context.systemVMs[0].id),
                                        dataType: 'json',
                                        async: true,
                                        success: function (json) {
                                            var jid = json.stopsystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                    },
                                                    getActionFilter: function () {
                                                        return systemvmActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            restart: {
                                label: 'label.action.reboot.systemvm',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.reboot.systemvm';
                                    },
                                    notification: function (args) {
                                        return 'label.action.reboot.systemvm';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL('rebootSystemVm&id=' + args.context.systemVMs[0].id),
                                        dataType: 'json',
                                        async: true,
                                        success: function (json) {
                                            var jid = json.rebootsystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                    },
                                                    getActionFilter: function () {
                                                        return systemvmActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            remove: {
                                label: 'label.action.destroy.systemvm',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.destroy.systemvm';
                                    },
                                    notification: function (args) {
                                        return 'label.action.destroy.systemvm';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL('destroySystemVm&id=' + args.context.systemVMs[0].id),
                                        dataType: 'json',
                                        async: true,
                                        success: function (json) {
                                            var jid = json.destroysystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    getUpdatedItem: function () {
                                                        return {
                                                            state: 'Destroyed'
                                                        };
                                                    },
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            migrate: {
                                label: 'label.action.migrate.systemvm',
                                messages: {
                                    notification: function (args) {
                                        return 'label.action.migrate.systemvm';
                                    }
                                },
                                createForm: {
                                    title: 'label.action.migrate.systemvm',
                                    desc: '',
                                    fields: {
                                        hostId: {
                                            label: 'label.host',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                $.ajax({
                                                    url: createURL("findHostsForMigration&VirtualMachineId=" + args.context.systemVMs[0].id),
                                                    dataType: "json",
                                                    async: true,
                                                    success: function (json) {
                                                        var hostObjs = json.findhostsformigrationresponse.host;
                                                        var items =[];
                                                        $(hostObjs).each(function () {
                                                            if (this.requiresStorageMotion == false) {
                                                                items.push({
                                                                    id: this.id,
                                                                    description: (this.name + " (" + (this.suitableformigration ? "Suitable": "Not Suitable") + ")")
                                                                });
                                                            }
                                                        });
                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                });
                                            },
                                            error: function (XMLHttpResponse) {
                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                args.response.error(errorMsg);
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("migrateSystemVm&hostid=" + args.data.hostId + "&virtualmachineid=" + args.context.systemVMs[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.migratesystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        //return json.queryasyncjobresultresponse.jobresult.systemvminstance;    //not all properties returned in systemvminstance
                                                        $.ajax({
                                                            url: createURL("listSystemVms&id=" + json.queryasyncjobresultresponse.jobresult.systemvm.id),
                                                            dataType: "json",
                                                            async: false,
                                                            success: function (json) {
                                                                var items = json.listsystemvmsresponse.systemvm;
                                                                if (items != null && items.length > 0) {
                                                                    return items[0];
                                                                }
                                                            }
                                                        });
                                                    },
                                                    getActionFilter: function () {
                                                        return systemvmActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            diagnostics: {
                                label: 'label.action.run.diagnostics',
                                messages: {
                                    notification: function (args) {
                                        return 'label.action.run.diagnostics';
                                    },
                                    complete: function(args) {
                                        var exitcode = _l('message.diagnostics.exitcode');
                                        exitcode = exitcode.replace('var', args.exitcode);
                                        var stderr = _l('message.diagnostics.stderr');
                                        stderr = stderr.replace('var', args.stderr);
                                        var stdout = _l('message.diagnostics.stdout');
                                        stdout = stdout.replace('var', args.stdout);
                                        var msg = "<div style='text-align: left; overflow-y: auto'>" + exitcode + "<br><br>" + stderr + "<br><br>" + stdout + "</div>";
                                        return msg;
                                    }
                                },
                                createForm: {
                                    title: 'label.action.run.diagnostics',
                                    desc: '',
                                    fields: {
                                        type: {
                                            label: 'label.run.diagnostics.type',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                var items = [];
                                                items.push({
                                                    id: "ping",
                                                    description: "Ping"
                                                });
                                                items.push({
                                                    id: "traceroute",
                                                    description: "Traceroute"
                                                });
                                                items.push({
                                                    id: "arping",
                                                    description: "Arping"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                        destination: {
                                            label: 'label.run.diagnostics.destination',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        extra: {
                                            label: 'label.run.diagnostics.extra'
                                        }

                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("runDiagnostics&targetid=" + args.context.systemVMs[0].id + "&ipaddress=" + args.data.destination + "&type=" + args.data.type + "&params=" + args.data.extra),
                                        dataType: "json",
                                        async: true,
                                        success: function(json) {
                                            var jid = json.rundiagnosticsresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId : jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                    },
                                                    getActionFilter: function(){
                                                        return systemvmActionfilter;
                                                   }
                                                }

                                            });
                                        }
                                    }); //end ajax
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            retrieveDiagnostics: {
                                label: 'label.action.get.diagnostics',
                                messages: {
                                    notification: function (args) {
                                        return 'label.action.get.diagnostics';
                                    },
                                    complete: function(args) {
                                        var url = args.url;
                                        var htmlMsg = _l('message.download.diagnostics');
                                        var htmlMsg2 = htmlMsg.replace(/#/, url).replace(/00000/, url);
                                        return htmlMsg2;
                                    }
                                },
                                createForm: {
                                    title: 'label.action.get.diagnostics',
                                    desc: 'label.get.diagnostics.desc',
                                    fields: {
                                        files: {
                                            label: 'label.get.diagnostics.files'
                                        }
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("getDiagnosticsData&targetid=" + args.context.systemVMs[0].id + "&files=" + args.data.files),
                                        dataType: "json",
                                        async: true,
                                        success: function(json) {
                                            var jid = json.getdiagnosticsdataresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId : jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.diagnostics;

                                                    },
                                                    getActionFilter: function(){
                                                        return systemvmActionfilter;
                                                   }
                                                }

                                            });
                                        }
                                    }); //end ajax
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            scaleUp: { //*** Infrastructure > System VMs (consoleProxy or SSVM) > change service offering ***
                                label: 'label.change.service.offering',
                                createForm: {
                                    title: 'label.change.service.offering',
                                    desc: function (args) {
                                        var description = '';
                                        var vmObj = args.jsonObj;
                                        //if (vmObj.state == 'Running' && vmObj.hypervisor == 'VMware') { //needs to wait for API fix that will return hypervisor property
                                        if (vmObj.state == 'Running') {
                                            description = 'message.read.admin.guide.scaling.up';
                                        }
                                        return description;
                                    },
                                    fields: {
                                        serviceOfferingId: {
                                            label: 'label.compute.offering',
                                            select: function (args) {
                                                var data1 = {
                                                    issystem: 'true',
                                                    virtualmachineid: args.context.systemVMs[0].id
                                                };
                                                if (args.context.systemVMs[0].systemvmtype == "secondarystoragevm") {
                                                    $.extend(data1, {
                                                        systemvmtype: 'secondarystoragevm'
                                                    });
                                                }
                                                else if (args.context.systemVMs[0].systemvmtype == "consoleproxy") {
                                                    $.extend(data1, {
                                                        systemvmtype: 'consoleproxy'
                                                    });
                                                }
                                                $.ajax({
                                                    url: createURL('listServiceOfferings'),
                                                    data: data1,
                                                    success: function (json) {
                                                        var serviceofferings = json.listserviceofferingsresponse.serviceoffering;
                                                        var items =[];
                                                        $(serviceofferings).each(function () {
                                                            if (this.id != args.context.systemVMs[0].serviceofferingid) {
                                                                items.push({
                                                                    id: this.id,
                                                                    description: this.name
                                                                });
                                                            }
                                                        });
                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                });
                                            }
                                        }
                                    }
                                },

                                action: function (args) {
                                    $.ajax({
                                        url: createURL("scaleSystemVm&id=" + args.context.systemVMs[0].id + "&serviceofferingid=" + args.data.serviceOfferingId),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.changeserviceforsystemvmresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.systemvm;
                                                    },
                                                    getActionFilter: function () {
                                                        return vmActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.scale.up.system.vm';
                                    },
                                    notification: function (args) {

                                        return 'label.system.vm.scaled.up';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            viewConsole: {
                                label: 'label.view.console',
                                action: {
                                    externalLink: {
                                        url: function (args) {
                                            return clientConsoleUrl + '?cmd=access&vm=' + args.context.systemVMs[0].id;
                                        },
                                        title: function (args) {
                                            return args.context.systemVMs[0].id.substr(0, 8);
                                            //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error.
                                        },
                                        width: 820,
                                        height: 640
                                    }
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    systemvmtype: {
                                        label: 'label.type',
                                        converter: function (args) {
                                            if (args == "consoleproxy")
                                            return "Console Proxy VM"; else if (args == "secondarystoragevm")
                                            return "Secondary Storage VM"; else
                                            return args;
                                        }
                                    },
                                    zonename: {
                                        label: 'label.zone'
                                    },
                                    publicip: {
                                        label: 'label.public.ip'
                                    },
                                    privateip: {
                                        label: 'label.private.ip'
                                    },
                                    linklocalip: {
                                        label: 'label.linklocal.ip'
                                    },
                                    hostname: {
                                        label: 'label.host'
                                    },
                                    gateway: {
                                        label: 'label.gateway'
                                    },
                                    created: {
                                        label: 'label.created',
                                        converter: cloudStack.converters.toLocalDate
                                    },
                                    activeviewersessions: {
                                        label: 'label.active.sessions'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listSystemVms&id=" + args.context.systemVMs[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            args.response.success({
                                                actionFilter: systemvmActionfilter,
                                                data: json.listsystemvmsresponse.systemvm[0]
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },
            // netscaler devices listView
            netscalerDevices: {
                id: 'netscalerDevices',
                title: 'label.devices',
                listView: {
                    id: 'netscalerDevices',
                    fields: {
                        ipaddress: {
                            label: 'label.ip.address'
                        },
                        lbdevicestate: {
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            label: 'label.status'
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listNetscalerLoadBalancers&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listnetscalerloadbalancerresponse.netscalerloadbalancer;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    actions: {
                        add: {
                            label: 'label.add.netScaler.device',
                            createForm: {
                                title: 'label.add.netScaler.device',
                                preFilter: cloudStack.preFilter.addLoadBalancerDevice,
                                fields: {
                                    ip: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    },
                                    networkdevicetype: {
                                        label: 'label.type',
                                        select: function (args) {
                                            var items =[];
                                            items.push({
                                                id: "NetscalerMPXLoadBalancer",
                                                description: "NetScaler MPX LoadBalancer"
                                            });
                                            items.push({
                                                id: "NetscalerVPXLoadBalancer",
                                                description: "NetScaler VPX LoadBalancer"
                                            });
                                            items.push({
                                                id: "NetscalerSDXLoadBalancer",
                                                description: "NetScaler SDX LoadBalancer"
                                            });
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    },
                                    publicinterface: {
                                        label: 'label.public.interface'
                                    },
                                    privateinterface: {
                                        label: 'label.private.interface'
                                    },

                                    gslbprovider: {
                                        label: 'label.gslb.service',
                                        isBoolean: true,
                                        isChecked: false
                                    },
                                    gslbproviderpublicip: {
                                        label: 'label.gslb.service.public.ip'
                                    },
                                    gslbproviderprivateip: {
                                        label: 'label.gslb.service.private.ip'
                                    },

                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    },
                                    /* inline: {
                                    label: 'Mode',
                                    select: function(args) {
                                    var items = [];
                                    items.push({id: "false", description: "side by side"});
                                    items.push({id: "true", description: "inline"});
                                    args.response.success({data: items});
                                    }
                                    },*/
                                    dedicated: {
                                        label: 'label.dedicated',
                                        isBoolean: true,
                                        isChecked: false
                                    },
                                    capacity: {
                                        label: 'label.capacity',
                                        validation: {
                                            required: false,
                                            number: true
                                        }
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "netscaler"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=Netscaler&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addNetscalerProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; //Job has not completed
                                                        } else {
                                                            clearInterval(addNetscalerProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "netscaler"] = result.jobresult.networkserviceprovider;
                                                                addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addNetscalerLoadBalancer", "addnetscalerloadbalancerresponse", "netscalerloadbalancer");
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else {
                                    addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addNetscalerLoadBalancer", "addnetscalerloadbalancerresponse", "netscalerloadbalancer");
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.add.netScaler.device';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    detailView: {
                        name: 'label.netscaler.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.NetScaler',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.NetScaler';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.NetScaler';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNetscalerLoadBalancer&lbdeviceid=" + args.context.netscalerDevices[0].lbdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletenetscalerloadbalancerresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        },

                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    lbdeviceid: {
                                        label: 'label.id'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    lbdevicestate: {
                                        label: 'label.status'
                                    },
                                    lbdevicename: {
                                        label: 'label.type'
                                    },
                                    lbdevicecapacity: {
                                        label: 'label.capacity'
                                    },
                                    lbdevicededicated: {
                                        label: 'label.dedicated',
                                        converter: cloudStack.converters.toBooleanText
                                    },
                                    gslbprovider: {
                                        label: 'label.gslb.service',
                                        converter: cloudStack.converters.toBooleanText
                                    },
                                    gslbproviderpublicip: {
                                        label: 'label.gslb.service.public.ip'
                                    },
                                    gslbproviderprivateip: {
                                        label: 'label.gslb.service.private.ip'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listNetscalerLoadBalancers&lbdeviceid=" + args.context.netscalerDevices[0].lbdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listnetscalerloadbalancerresponse.netscalerloadbalancer[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },

            // Baremetal DHCP devices listView
            BaremetalDhcpDevices: {
                id: 'BaremetalDhcpDevices',
                title: 'label.baremetal.dhcp.devices',
                listView: {
                    id: 'BaremetalDhcpDevices',
                    fields: {
                        url: {
                            label: 'label.url'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.baremetal.dhcp.device',
                            createForm: {
                                title: 'label.add.baremetal.dhcp.device',
                                fields: {
                                    url: {
                                        label: 'label.url',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    username: {
                                        label: 'label.username',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true,
                                        validation: {
                                            required: true
                                        }
                                    }
                                }
                            },
                            action: function (args) {
                                addBaremetalDhcpDeviceFn(args);
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.add.baremetal.dhcp.device';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL('listBaremetalDhcp'),
                            data: {
                                physicalnetworkid: selectedPhysicalNetworkObj.id,
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listbaremetaldhcpresponse.baremetaldhcp;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    }
                }
            },

            // Baremetal PXE devices listView
            BaremetalPxeDevices: {
                id: 'BaremetalPxeDevices',
                title: 'label.baremetal.pxe.devices',
                listView: {
                    id: 'BaremetalPxeDevices',
                    fields: {
                        url: {
                            label: 'label.url'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.baremetal.pxe.device',
                            createForm: {
                                title: 'label.baremetal.pxe.device',
                                fields: {
                                    url: {
                                        label: 'label.url',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    username: {
                                        label: 'label.username',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true,
                                        validation: {
                                            required: true
                                        }
                                    },
                                    tftpdir: {
                                        label: 'label.tftp.root.directory',
                                        validation: {
                                            required: true
                                        }
                                    }
                                }
                            },
                            action: function (args) {
                                addBaremetalPxeDeviceFn(args);
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.baremetal.pxe.device';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL('listBaremetalPxeServers'),
                            data: {
                                physicalnetworkid: selectedPhysicalNetworkObj.id,
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listbaremetalpxeserversresponse.baremetalpxeserver;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    }
                }
            },

            // F5 devices listView
            f5Devices: {
                id: 'f5Devices',
                title: 'label.devices',
                listView: {
                    id: 'f5Devices',
                    fields: {
                        ipaddress: {
                            label: 'label.ip.address'
                        },
                        lbdevicestate: {
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            label: 'label.status'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.F5.device',
                            createForm: {
                                title: 'label.add.F5.device',
                                preFilter: cloudStack.preFilter.addLoadBalancerDevice,
                                fields: {
                                    ip: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    },
                                    networkdevicetype: {
                                        label: 'label.type',
                                        select: function (args) {
                                            var items =[];
                                            items.push({
                                                id: "F5BigIpLoadBalancer",
                                                description: "F5 Big Ip Load Balancer"
                                            });
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    },
                                    publicinterface: {
                                        label: 'label.public.interface'
                                    },
                                    privateinterface: {
                                        label: 'label.private.interface'
                                    },
                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    },
                                    //Inline Mode has been moved from Add F5 Device to Create Network Offering (both backend and UI)
                                    /*
                                    inline: {
                                    label: 'Mode',
                                    select: function(args) {
                                    var items = [];
                                    items.push({id: "false", description: "side by side"});
                                    items.push({id: "true", description: "inline"});
                                    args.response.success({data: items});
                                    }
                                    },
                                     */
                                    dedicated: {
                                        label: 'label.dedicated',
                                        isBoolean: true,
                                        isChecked: false
                                    },
                                    capacity: {
                                        label: 'label.capacity',
                                        validation: {
                                            required: false,
                                            number: true
                                        }
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "f5"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=F5BigIp&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addF5ProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; //Job has not completed
                                                        } else {
                                                            clearInterval(addF5ProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "f5"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addF5LoadBalancer", "addf5bigiploadbalancerresponse", "f5loadbalancer");
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=F5BigIp failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=F5BigIpfailed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else {
                                    addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addF5LoadBalancer", "addf5bigiploadbalancerresponse", "f5loadbalancer");
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.addes.new.f5';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listF5LoadBalancers&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listf5loadbalancerresponse.f5loadbalancer;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.f5.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.F5',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.F5';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.F5';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteF5LoadBalancer&lbdeviceid=" + args.context.f5Devices[0].lbdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletef5loadbalancerresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    lbdeviceid: {
                                        label: 'label.id'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    lbdevicestate: {
                                        label: 'label.status'
                                    },
                                    lbdevicename: {
                                        label: 'label.type'
                                    },
                                    lbdevicecapacity: {
                                        label: 'label.capacity'
                                    },
                                    lbdevicededicated: {
                                        label: 'label.dedicated',
                                        converter: cloudStack.converters.toBooleanText
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listF5LoadBalancers&lbdeviceid=" + args.context.f5Devices[0].lbdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listf5loadbalancerresponse.f5loadbalancer[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },

            //SRX devices listView
            srxDevices: {
                id: 'srxDevices',
                title: 'label.devices',
                listView: {
                    id: 'srxDevices',
                    fields: {
                        ipaddress: {
                            label: 'label.ip.address'
                        },
                        fwdevicestate: {
                            label: 'label.status'
                        },
                        fwdevicename: {
                            label: 'label.type'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.SRX.device',
                            createForm: {
                                title: 'label.add.SRX.device',
                                fields: {
                                    ip: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    },
                                    networkdevicetype: {
                                        label: 'label.type',
                                        select: function (args) {
                                            var items =[];
                                            items.push({
                                                id: "JuniperSRXFirewall",
                                                description: "Juniper SRX Firewall"
                                            });
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    },
                                    publicinterface: {
                                        label: 'label.public.interface'
                                    },
                                    privateinterface: {
                                        label: 'label.private.interface'
                                    },
                                    usageinterface: {
                                        label: 'label.usage.interface'
                                    },
                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    },
                                    timeout: {
                                        label: 'label.timeout',
                                        defaultValue: '300'
                                    },
                                    // inline: {
                                    //   label: 'Mode',
                                    //   select: function(args) {
                                    //     var items = [];
                                    //     items.push({id: "false", description: "side by side"});
                                    //     items.push({id: "true", description: "inline"});
                                    //     args.response.success({data: items});
                                    //   }
                                    // },
                                    publicnetwork: {
                                        label: 'label.public.network',
                                        defaultValue: 'untrusted',
                                        isDisabled: true
                                    },
                                    privatenetwork: {
                                        label: 'label.private.network',
                                        defaultValue: 'trusted',
                                        isDisabled: true
                                    },
                                    capacity: {
                                        label: 'label.capacity',
                                        validation: {
                                            required: false,
                                            number: true
                                        }
                                    },
                                    dedicated: {
                                        label: 'label.dedicated',
                                        isBoolean: true,
                                        isChecked: false
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "srx"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=JuniperSRX&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addJuniperSRXProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; //Job has not completed
                                                        } else {
                                                            clearInterval(addJuniperSRXProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "srx"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addExternalFirewall(args, selectedPhysicalNetworkObj, "addSrxFirewall", "addsrxfirewallresponse", "srxfirewall");
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=JuniperSRX failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=JuniperSRX failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else {
                                    addExternalFirewall(args, selectedPhysicalNetworkObj, "addSrxFirewall", "addsrxfirewallresponse", "srxfirewall");
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.add.SRX.device';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listSrxFirewalls&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listsrxfirewallresponse.srxfirewall;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.srx.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.SRX',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.SRX';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.SRX';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteSrxFirewall&fwdeviceid=" + args.context.srxDevices[0].fwdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletesrxfirewallresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    fwdeviceid: {
                                        label: 'label.id'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    fwdevicestate: {
                                        label: 'label.status'
                                    },
                                    fwdevicename: {
                                        label: 'label.type'
                                    },
                                    fwdevicecapacity: {
                                        label: 'label.capacity'
                                    },
                                    timeout: {
                                        label: 'label.timeout'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listSrxFirewalls&fwdeviceid=" + args.context.srxDevices[0].fwdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listsrxfirewallresponse.srxfirewall[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },

            //Palo Alto devices listView
            paDevices: {
                id: 'paDevices',
                title: 'label.devices',
                listView: {
                    id: 'paDevices',
                    fields: {
                        ipaddress: {
                            label: 'label.ip.address'
                        },
                        fwdevicestate: {
                            label: 'label.status'
                        },
                        fwdevicename: {
                            label: 'label.type'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.PA.device',
                            createForm: {
                                title: 'label.add.PA.device',
                                fields: {
                                    ip: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    },
                                    networkdevicetype: {
                                        label: 'label.type',
                                        select: function (args) {
                                            var items =[];
                                            items.push({
                                                id: "PaloAltoFirewall",
                                                description: "Palo Alto Firewall"
                                            });
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    },
                                    publicinterface: {
                                        label: 'label.public.interface'
                                    },
                                    privateinterface: {
                                        label: 'label.private.interface'
                                    },
                                    //usageinterface: {
                                    //  label: 'label.usage.interface'
                                    //},
                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    },
                                    timeout: {
                                        label: 'label.timeout',
                                        defaultValue: '300'
                                    },
                                    // inline: {
                                    //   label: 'Mode',
                                    //   select: function(args) {
                                    //     var items = [];
                                    //     items.push({id: "false", description: "side by side"});
                                    //     items.push({id: "true", description: "inline"});
                                    //     args.response.success({data: items});
                                    //   }
                                    // },
                                    publicnetwork: {
                                        label: 'label.public.network',
                                        defaultValue: 'untrust'
                                    },
                                    privatenetwork: {
                                        label: 'label.private.network',
                                        defaultValue: 'trust'
                                    },
                                    pavr: {
                                        label: 'label.virtual.router'
                                    },
                                    patp: {
                                        label: 'label.PA.threat.profile'
                                    },
                                    palp: {
                                        label: 'label.PA.log.profile'
                                    },
                                    capacity: {
                                        label: 'label.capacity',
                                        validation: {
                                            required: false,
                                            number: true
                                        }
                                    },
                                    dedicated: {
                                        label: 'label.dedicated',
                                        isBoolean: true,
                                        isChecked: false
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "pa"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=PaloAlto&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addPaloAltoProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; //Job has not completed
                                                        } else {
                                                            clearInterval(addPaloAltoProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "pa"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addExternalFirewall(args, selectedPhysicalNetworkObj, "addPaloAltoFirewall", "addpaloaltofirewallresponse", "pafirewall");
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=Palo Alto failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=Palo Alto failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            3000);
                                        }
                                    });
                                } else {
                                    addExternalFirewall(args, selectedPhysicalNetworkObj, "addPaloAltoFirewall", "addpaloaltofirewallresponse", "pafirewall");
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.add.PA.device';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listPaloAltoFirewalls&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listpaloaltofirewallresponse.paloaltofirewall;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.palo.alto.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.PA',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.PA';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.PA';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deletePaloAltoFirewall&fwdeviceid=" + args.context.paDevices[0].fwdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletepaloaltofirewallresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    fwdeviceid: {
                                        label: 'label.id'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    fwdevicestate: {
                                        label: 'label.status'
                                    },
                                    fwdevicename: {
                                        label: 'label.type'
                                    },
                                    fwdevicecapacity: {
                                        label: 'label.capacity'
                                    },
                                    timeout: {
                                        label: 'label.timeout'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listPaloAltoFirewalls&fwdeviceid=" + args.context.paDevices[0].fwdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listpaloaltofirewallresponse.paloaltofirewall[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },

            // FIXME convert to nicira detailview
            // NiciraNvp devices listView
            niciraNvpDevices: {
                id: 'niciraNvpDevices',
                title: 'label.devices',
                listView: {
                    id: 'niciraNvpDevices',
                    fields: {
                        hostname: {
                            label: 'label.nicira.controller.address'
                        },
                        transportzoneuuid: {
                            label: 'label.nicira.transportzoneuuid'
                        },
                        l3gatewayserviceuuid: {
                            label: 'label.nicira.l3gatewayserviceuuid'
                        },
						l2gatewayserviceuuid: {
                            label: 'label.nicira.l2gatewayserviceuuid'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.NiciraNvp.device',
                            createForm: {
                                title: 'label.add.NiciraNvp.device',
                                preFilter: function (args) {
                                },
                                // TODO What is this?
                                fields: {
                                    host: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    },
                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    },
                                    transportzoneuuid: {
                                        label: 'label.nicira.transportzoneuuid'
                                    },
                                    l3gatewayserviceuuid: {
                                        label: 'label.nicira.l3gatewayserviceuuid'
                                    },
									l2gatewayserviceuuid: {
										label: 'label.nicira.l2gatewayserviceuuid'
									}
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "niciraNvp"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=NiciraNvp&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addNiciraNvpProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; // Job has not completed
                                                        } else {
                                                            clearInterval(addNiciraNvpProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "niciraNvp"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addNiciraNvpDevice(args, selectedPhysicalNetworkObj, "addNiciraNvpDevice", "addniciranvpdeviceresponse", "niciranvpdevice")
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=NiciraNvp failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=NiciraNvp failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else {
                                    addNiciraNvpDevice(args, selectedPhysicalNetworkObj, "addNiciraNvpDevice", "addniciranvpdeviceresponse", "niciranvpdevice")
                                }
                            },

                            messages: {
                                notification: function (args) {
                                    return 'label.added.nicira.nvp.controller';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listNiciraNvpDevices&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listniciranvpdeviceresponse.niciranvpdevice;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.nicira.nvp.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.NiciaNvp',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.NiciraNvp';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.NiciraNvp';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteNiciraNvpDevice&nvpdeviceid=" + args.context.niciraNvpDevices[0].nvpdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deleteniciranvpdeviceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    nvpdeviceid: {
                                        label: 'label.id'
                                    },
                                    hostname: {
                                        label: 'label.ip.address'
                                    },
                                    transportzoneuuid: {
                                        label: 'label.nicira.transportzoneuuid'
                                    },
                                    l3gatewayserviceuuid: {
                                        label: 'label.nicira.l3gatewayserviceuuid'
                                    },
									l2gatewayserviceuuid: {
										label: 'label.nicira.l2gatewayserviceuuid'
									}
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listNiciraNvpDevices&nvpdeviceid=" + args.context.niciraNvpDevices[0].nvpdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listniciranvpdeviceresponse.niciranvpdevice[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },
            // BrocadeVcs devices listView
            brocadeVcsDevices: {
                id: 'brocadeVcsDevices',
                title: 'label.devices',
                listView: {
                    id: 'brocadeVcsDevices',
                    fields: {
                        hostname: {
                            label: 'label.brocade.vcs.address'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.BrocadeVcs.device',
                            createForm: {
                                title: 'label.add.BrocadeVcs.device',
                                preFilter: function (args) {
                                },
                                // TODO What is this?
                                fields: {
                                    host: {
                                        label: 'label.ip.address'
                                    },
                                    username: {
                                        label: 'label.username'
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "brocadeVcs"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=BrocadeVcs&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addBrocadeVcsProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; // Job has not completed
                                                        } else {
                                                            clearInterval(addBrocadeVcsProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "brocadeVcs"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addBrocadeVcsDevice(args, selectedPhysicalNetworkObj, "addBrocadeVcsDevice", "addbrocadevcsdeviceresponse", "brocadevcsdevice")
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=BrocadeVcs failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=BrocadeVcs failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else {
                                    addBrocadeVcsDevice(args, selectedPhysicalNetworkObj, "addBrocadeVcsDevice", "addbrocadevcsdeviceresponse", "brocadevcsdevice")
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.added.brocade.vcs.switch';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listBrocadeVcsDevices&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listbrocadevcsdeviceresponse.brocadevcsdevice;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.brocade.vcs.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.BrocadeVcs',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.BrocadeVcs';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.BrocadeVcs';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteBrocadeVcsDevice&vcsdeviceid=" + args.context.brocadeVcsDevices[0].vcsdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletebrocadevcsdeviceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    vcsdeviceid: {
                                        label: 'label.id'
                                    },
                                    hostname: {
                                        label: 'label.ip.address'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listBrocadeVcsDevices&vcsdeviceid=" + args.context.brocadeVcsDevices[0].vcsdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listbrocadevcsdeviceresponse.brocadevcsdevice[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },
            bigswitchBcfDevices: {
                id: 'bigswitchBcfDevices',
                title: 'label.devices',
                listView: {
                    id: 'bigswitchBcfDevices',
                    fields: {
                        hostname: {
                            label: 'label.bigswitch.controller.address'
                        }
                    },
                    actions: {
                        add: {
                            label: 'label.add.BigSwitchBcf.device',
                            createForm: {
                                title: 'label.add.BigSwitchBcf.device',
                                preFilter: function (args) {
                                },
                                fields: {
                                    host: {
                                        label: 'label.ip.address',
                                        validation: {
                                                     required: true
                                                 }
                                    },
                                    username: {
                                        label: 'label.username',
                                        validation: {
                                                     required: true
                                                 }
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true,
                                        validation: {
                                                     required: true
                                                 }
                                    },
                                    nat: {
                                                label: 'label.bigswitch.bcf.nat',
                                                isBoolean: true,
                                                isChecked: false
                                    },
                                    numretries: {
                                        label: 'label.numretries',
                                        defaultValue: '2'
                                    }
                                }
                            },
                            action: function (args) {
                                if (nspMap[ "bigswitchBcf"] == null) {
                                    $.ajax({
                                        url: createURL("addNetworkServiceProvider&name=BigSwitchBcf&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jobId = json.addnetworkserviceproviderresponse.jobid;
                                            var addBigSwitchBcfProviderIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return;
                                                        } else {
                                                            clearInterval(addBigSwitchBcfProviderIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                nspMap[ "bigswitchBcf"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
                                                                addBigSwitchBcfDevice(args, selectedPhysicalNetworkObj, "addBigSwitchBcfDevice", "addbigswitchbcfdeviceresponse", "bigswitchbcfdevice")
                                                            } else if (result.jobstatus == 2) {
                                                                alert("addNetworkServiceProvider&name=BigSwitchBcf failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("addNetworkServiceProvider&name=BigSwitchBcf failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            3000);
                                        }
                                    });
                                } else {
                                    addBigSwitchBcfDevice(args, selectedPhysicalNetworkObj, "addBigSwitchBcfDevice", "addbigswitchbcfdeviceresponse", "bigswitchbcfdevice")
                                }
                            },

                            messages: {
                                notification: function (args) {
                                    return 'label.added.new.bigswitch.bcf.controller';
                                }
                            },
                            notification: {
                                poll: pollAsyncJobResult
                            }
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listBigSwitchBcfDevices&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            data: {
                                page: args.page,
                                pageSize: pageSize
                            },
                            dataType: "json",
                            async: false,
                            success: function (json) {
                                var items = json.listbigswitchbcfdeviceresponse.bigswitchbcfdevice;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    detailView: {
                        name: 'label.bigswitch.bcf.details',
                        actions: {
                            'remove': {
                                label: 'label.delete.BigSwitchBcf',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.BigSwitchBcf';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.BigSwitchBcf';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteBigSwitchBcfDevice&bcfdeviceid=" + args.context.bigswitchBcfDevices[0].bcfdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.deletebigswitchbcfdeviceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    bcfdeviceid: {
                                        label: 'label.id'
                                    },
                                    hostname: {
                                        label: 'label.host.name'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listBigSwitchBcfDevices&bcfdeviceid=" + args.context.bigswitchBcfDevices[0].bcfdeviceid),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listbigswitchbcfdeviceresponse.bigswitchbcfdevice[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },
            pods: {
                title: 'label.pods',
                listView: {
                    id: 'pods',
                    section: 'pods',
                    multiSelect: true,
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        gateway: {
                            label: 'label.gateway'
                        },
                        netmask: {
                            label: 'label.netmask'
                        },
                        zonename: {
                            label: 'label.zone'
                        },
                        allocationstate: {
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            label: 'label.allocation.state',
                            indicator: {
                                'Enabled': 'on',
                                'Disabled': 'off'
                            }
                        }
                    },

                    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=" + args.context.zones[0].id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.listpodsresponse.pod;
                                args.response.success({
                                    actionFilter: podActionfilter,
                                    data: items
                                });
                            }
                        });
                    },

                    actions: {
                        add: {
                            label: 'label.add.pod',

                            createForm: {
                                title: 'label.add.pod',
                                fields: {
                                    zoneid: {
                                        label: 'label.zone',
                                        docID: 'helpPodZone',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            var data = args.context.zones ? {
                                                id: args.context.zones[0].id
                                            }: {};

                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: data,
                                                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
                                                            };
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    podname: {
                                        label: 'label.pod.name',
                                        docID: 'helpPodName',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    reservedSystemGateway: {
                                        label: 'label.reserved.system.gateway',
                                        docID: 'helpPodGateway',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    reservedSystemNetmask: {
                                        label: 'label.reserved.system.netmask',
                                        docID: 'helpPodNetmask',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    reservedSystemStartIp: {
                                        label: 'label.start.reserved.system.IP',
                                        docID: 'helpPodStartIP',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    reservedSystemEndIp: {
                                        label: 'label.end.reserved.system.IP',
                                        docID: 'helpPodEndIP',
                                        validation: {
                                            required: false
                                        }
                                    },

                                    isDedicated: {
                                        label: 'label.dedicate',
                                        isBoolean: true,
                                        isChecked: false,
                                        docID: 'helpDedicateResource'
                                    },

                                    domainId: {
                                        label: 'label.domain',
                                        isHidden: true,
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'isDedicated',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL('listDomains'),
                                                data: {
                                                    listAll: true,
                                                    details: 'min'
                                                },
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    var domainObjs = json.listdomainsresponse.domain;
                                                    var items =[];

                                                    $(domainObjs).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    items.sort(function(a, b) {
                                                        return a.description.localeCompare(b.description);
                                                    });

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

                                    accountId: {
                                        label: 'label.account',
                                        isHidden: true,
                                        dependsOn: 'isDedicated',
                                        docID: 'helpAccountForDedication',
                                        validation: {
                                            required: false
                                        }
                                    }
                                }
                            },

                            action: function (args) {
                                var array1 =[];
                                var appendData = args.data.append ? args.data.append: {
                                };

                                array1.push("&zoneId=" + args.data.zoneid);
                                array1.push("&name=" + encodeURIComponent(args.data.podname));
                                array1.push("&gateway=" + encodeURIComponent(args.data.reservedSystemGateway));
                                array1.push("&netmask=" + encodeURIComponent(args.data.reservedSystemNetmask));
                                array1.push("&startIp=" + encodeURIComponent(args.data.reservedSystemStartIp));

                                var endip = args.data.reservedSystemEndIp; //optional
                                if (endip != null && endip.length > 0)
                                array1.push("&endIp=" + encodeURIComponent(endip));
                                var podId = null;
                                $.ajax({
                                    url: createURL("createPod" + array1.join("")),
                                    data: appendData,
                                    dataType: "json",
                                    success: function (json) {
                                        var item = json.createpodresponse.pod;
                                        podId = json.createpodresponse.pod.id;

                                        //EXPLICIT DEDICATION
                                        if (args.$form.find('.form-item[rel=isDedicated]').find('input[type=checkbox]').is(':Checked') == true) {
                                            var array2 =[];
                                            if (args.data.accountId != "")
                                            array2.push("&account=" + encodeURIComponent(args.data.accountId));

                                            if (podId != null) {
                                                $.ajax({
                                                    url: createURL("dedicatePod&podId=" + podId + "&domainId=" + args.data.domainId + array2.join("")),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var jid = json.dedicatepodresponse.jobid;
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jid
                                                            },
                                                            notification: {
                                                                poll: pollAsyncJobResult,
                                                                interval: 4500,
                                                                desc: "Dedicate Pod"
                                                            },

                                                            data: item
                                                        });
                                                    },

                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                    }
                                                });
                                            }
                                        }
                                        args.response.success({
                                            data: item
                                        });
                                    },
                                    error: function (XMLHttpResponse) {
                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                        args.response.error(errorMsg);
                                    }
                                });
                            },

                            notification: {
                                poll: function (args) {
                                    args.complete({
                                        actionFilter: podActionfilter
                                    });
                                }
                            },

                            messages: {
                                notification: function (args) {
                                    return 'label.add.pod';
                                }
                            }
                        },
                        startRollingMaintenance: rollingMaintenanceAction({ listView: true, entity: 'pods' })
                    },

                    detailView: {
                        viewAll: {
                            path: '_zone.clusters',
                            label: 'label.clusters'
                        },
                        tabFilter: function (args) {
                            var hiddenTabs =[];
                            if (selectedZoneObj.networktype == "Basic") {
                                //basic-mode network (pod-wide VLAN)
                                //$("#tab_ipallocation, #add_iprange_button, #tab_network_device, #add_network_device_button").show();
                            } else if (selectedZoneObj.networktype == "Advanced") {
                                //advanced-mode network (zone-wide VLAN)
                                //$("#tab_ipallocation, #add_iprange_button, #tab_network_device, #add_network_device_button").hide();
                                hiddenTabs.push("ipAllocations");
                                //hiddenTabs.push("networkDevices"); //network devices tab is moved out of pod page at 3.0 UI. It will go to new network page.
                            }
                            return hiddenTabs;
                        },
                        actions: {
                            startRollingMaintenance: {
                                label: 'label.start.rolling.maintenance',
                                textLabel: 'label.start.rolling.maintenance',
                                messages: {
                                    notification: function (args) {
                                        return 'label.start.rolling.maintenance';
                                    }
                                },
                                createForm: {
                                    title: 'label.start.rolling.maintenance',
                                    fields: {
                                        timeout: {
                                            label: 'label.timeout',
                                        },
                                        force: {
                                            isBoolean: true,
                                            label: 'label.start.rolling.maintenance.force'
                                        },
                                        payload: {
                                            label: 'label.start.rolling.maintenance.payload'
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = {
                                        podids: args.context.pods[0].id,
                                        force: args.data.force,
                                        timeout: args.data.timeout,
                                        payload: args.data.payload
                                    };
                                    $.ajax({
                                        url: createURL("startRollingMaintenance"),
                                        dataType: "json",
                                        data: data,
                                        async: true,
                                        success: function (json) {
                                            var item = json.rollingmaintenance;
                                            args.response.success({
                                                actionFilter: zoneActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            edit: {
                                label: 'label.edit',
                                action: function (args) {
                                    var array1 =[];

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

                                    if (args.data.gateway != null && args.data.gateway.length > 0)
                                    array1.push("&gateway=" + encodeURIComponent(args.data.gateway));

                                    $.ajax({
                                        url: createURL("updatePod&id=" + args.context.pods[0].id + array1.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var item = json.updatepodresponse.pod;
                                            args.response.success({
                                                actionFilter: podActionfilter,
                                                data: item
                                            });
                                        },
                                        error: function (data) {
                                            args.response.error(parseXMLHttpResponse(data));
                                        }
                                    });
                                }
                            },

                            enable: {
                                label: 'label.action.enable.pod',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.enable.pod';
                                    },
                                    notification: function (args) {
                                        return 'label.action.enable.pod';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updatePod&id=" + args.context.pods[0].id + "&allocationstate=Enabled"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updatepodresponse.pod;
                                            args.response.success({
                                                actionFilter: podActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            dedicate: {
                                label: 'label.dedicate.pod',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.dedicate.pod.domain.account';
                                    },
                                    notification: function (args) {
                                        return 'label.pod.dedicated';
                                    }
                                },
                                createForm: {
                                    title: 'label.dedicate.pod',
                                    fields: {
                                        domainId: {
                                            label: 'label.domain',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                $.ajax({
                                                    url: createURL('listDomains'),
                                                    data: {
                                                        listAll: true,
                                                        details: 'min'
                                                    },
                                                    dataType: "json",
                                                    async: false,
                                                    success: function (json) {
                                                        var domainObjs = json.listdomainsresponse.domain;
                                                        var items =[];

                                                        $(domainObjs).each(function () {
                                                            items.push({
                                                                id: this.id,
                                                                description: this.name
                                                            });
                                                        });
                                                        items.sort(function(a, b) {
                                                            return a.description.localeCompare(b.description);
                                                        });

                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                });
                                            }
                                        },
                                        accountId: {
                                            label: 'label.account',
                                            docID: 'helpAccountForDedication',
                                            validation: {
                                                required: false
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    //EXPLICIT DEDICATION
                                    var array2 =[];
                                    if (args.data.accountId != "")
                                    array2.push("&account=" + encodeURIComponent(args.data.accountId));

                                    $.ajax({
                                        url: createURL("dedicatePod&podId=" +
                                        args.context.pods[0].id +
                                        "&domainId=" + args.data.domainId + array2.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.dedicatepodresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return podActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            release: {
                                label: 'label.release.dedicated.pod',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.release.dedicated.pod';
                                    },
                                    notification: function (args) {
                                        return 'message.pod.dedication.released';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("releaseDedicatedPod&podid=" + args.context.pods[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.releasededicatedpodresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return podActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },


                            disable: {
                                label: 'label.action.disable.pod',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.disable.pod';
                                    },
                                    notification: function (args) {
                                        return 'label.action.disable.pod';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updatePod&id=" + args.context.pods[0].id + "&allocationstate=Disabled"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updatepodresponse.pod;
                                            args.response.success({
                                                actionFilter: podActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            'remove': {
                                label: 'label.delete',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.delete.pod';
                                    },
                                    notification: function (args) {
                                        return 'label.action.delete.pod';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deletePod&id=" + args.context.pods[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            args.response.success({
                                                data: {
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name',
                                        isEditable: true,
                                        validation: {
                                            required: true
                                        }
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    netmask: {
                                        label: 'label.netmask',
                                        isEditable: true,
                                        validation: {
                                            required: true
                                        }
                                    },
                                    gateway: {
                                        label: 'label.gateway',
                                        isEditable: true,
                                        validation: {
                                            required: true
                                        }
                                    },
                                    allocationstate: {
                                        converter: function (str) {
                                            // For localization
                                            return str;
                                        },
                                        label: 'label.allocation.state'
                                    }
                                }, {
                                    isdedicated: {
                                        label: 'label.dedicated'
                                    },
                                    domainid: {
                                        label: 'label.domain.id'
                                    }
                                }],

                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listPods&id=" + args.context.pods[0].id),
                                        success: function (json) {
                                            var item = json.listpodsresponse.pod[0];
                                            $.ajax({
                                                url: createURL("listDedicatedPods&podid=" + args.context.pods[0].id),
                                                success: function (json) {
                                                    if (json.listdedicatedpodsresponse.dedicatedpod != undefined) {
                                                        var podItem = json.listdedicatedpodsresponse.dedicatedpod[0];
                                                        if (podItem.domainid != null) {
                                                            $.extend(item, podItem, {
                                                                isdedicated: _l('label.yes')
                                                            });
                                                        }
                                                    } else
                                                    $.extend(item, {
                                                        isdedicated: _l('label.no')
                                                    });

                                                    args.response.success({
                                                        actionFilter: podActionfilter,
                                                        data: item
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                }
                                            });
                                            //  args.response.success({
                                            //     actionFilter: podActionfilter,
                                            //     data: item
                                            // });
                                        }
                                    });
                                }
                            },

                            ipAllocations: {
                                title: 'label.ip.allocations',
                                multiple: true,
                                fields:[ {
                                    id: {
                                        label: 'label.id'
                                    },
                                    gateway: {
                                        label: 'label.gateway'
                                    },
                                    netmask: {
                                        label: 'label.netmask'
                                    },
                                    startip: {
                                        label: 'label.start.IP'
                                    },
                                    endip: {
                                        label: 'label.end.IP'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listVlanIpRanges&zoneid=" + args.context.zones[0].id + "&podid=" + args.context.pods[0].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var items = json.listvlaniprangesresponse.vlaniprange;
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            },
            clusters: {
                title: 'label.clusters',
                listView: {
                    id: 'clusters',
                    section: 'clusters',
                    multiSelect: true,
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        hypervisortype: {
                            label: 'label.hypervisor'
                        },
                        zonename: {
                            label: 'label.zone'
                        },
                        podname: {
                            label: 'label.pod'
                        },
                        managedstate: {
                            label: 'label.managed.state'
                        },
                        allocationstate: {
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            label: 'label.allocation.state',
                            indicator: {
                                'Enabled': 'on',
                                'Disabled': 'off'
                            }
                        }
                    },

                    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;
                                }
                            }
                        }
                        array1.push("&zoneid=" + args.context.zones[0].id);
                        if ("pods" in args.context)
                        array1.push("&podid=" + args.context.pods[0].id);
                        $.ajax({
                            url: createURL("listClusters" + array1.join("") + "&page=" + args.page + "&pagesize=" + pageSize),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.listclustersresponse.cluster;
                                $(items).each(function () {
                                    addExtraPropertiesToClusterObject(this);
                                });

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

                    actions: {
                        add: {
                            label: 'label.add.cluster',
                            messages: {
                                notification: function (args) {
                                    return 'label.add.cluster';
                                }
                            },
                            createForm: {
                                title: 'label.add.cluster',
                                preFilter: function (args) {
                                    var $form = args.$form;
                                    $form.click(function () {
                                        var $nexusDvsOptFields = $form.find('.form-item').filter(function () {
                                            var nexusDvsOptFields =[
                                            'vsmipaddress',
                                            'vsmusername',
                                            'vsmpassword'];
                                            return $.inArray($(this).attr('rel'), nexusDvsOptFields) > -1;
                                        });
                                        var $nexusDvsReqFields = $form.find('.form-item').filter(function () {
                                            var nexusDvsReqFields =[
                                            'vsmipaddress_req',
                                            'vsmusername_req',
                                            'vsmpassword_req'];
                                            return $.inArray($(this).attr('rel'), nexusDvsReqFields) > -1;
                                        });

                                        if ($form.find('.form-item[rel=hypervisor] select').val() == 'VMware') {
                                            $form.find('.form-item[rel=vCenterHost]').css('display', 'inline-block');
                                            $form.find('.form-item[rel=vCenterUsername]').css('display', 'inline-block');
                                            $form.find('.form-item[rel=vCenterPassword]').css('display', 'inline-block');
                                            $form.find('.form-item[rel=vCenterDatacenter]').css('display', 'inline-block');

                                            var $overridePublicTraffic = $form.find('.form-item[rel=overridepublictraffic] input[type=checkbox]');
                                            var $vSwitchPublicType = $form.find('.form-item[rel=vSwitchPublicType] select');
                                            var $overrideGuestTraffic = $form.find('.form-item[rel=overrideguesttraffic] input[type=checkbox]');
                                            var $vSwitchGuestType = $form.find('.form-item[rel=vSwitchGuestType] select');


                                            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) {
                                                //If using Distributed vswitch, there is OverrideTraffic option.
                                                $form.find('.form-item[rel=overridepublictraffic]').css('display', 'inline-block');
                                                $form.find('.form-item[rel=overrideguesttraffic]').css('display', 'inline-block');

                                                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) {
                                                    //If using Nexus Distributed vswitch, show Nexus Distributed vswitch fields (either required ones or optional ones).
                                                    if (($overridePublicTraffic.is(':checked') && $vSwitchPublicType.val() == 'nexusdvs') ||
                                                    ($overrideGuestTraffic.is(':checked') && $vSwitchGuestType.val() == 'nexusdvs')) {
                                                        $nexusDvsReqFields.css('display', 'inline-block');
                                                        $nexusDvsOptFields.hide();
                                                    } else {
                                                        $nexusDvsOptFields.css('display', 'inline-block');
                                                        $nexusDvsReqFields.hide();
                                                    }
                                                } else {
                                                    //If not using Nexus Distributed vswitch, hide Nexus Distributed vswitch fields.
                                                    $nexusDvsOptFields.hide();
                                                    $nexusDvsReqFields.hide();
                                                }
                                            } else {
                                                //useDvs == false
                                                $form.find('.form-item[rel=overridepublictraffic]').css('display', 'none');
                                                $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'none');
                                                $form.find('.form-item[rel=vSwitchPublicName]').css('display', 'none');

                                                $form.find('.form-item[rel=overrideguesttraffic]').css('display', 'none');
                                                $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'none');
                                                $form.find('.form-item[rel=vSwitchGuestName]').css('display', 'none');

                                                $nexusDvsOptFields.hide();
                                                $nexusDvsReqFields.hide();
                                            }
                                        } else {
                                            //XenServer, KVM, etc (non-VMware)
                                            $form.find('.form-item[rel=vCenterHost]').css('display', 'none');
                                            $form.find('.form-item[rel=vCenterUsername]').css('display', 'none');
                                            $form.find('.form-item[rel=vCenterPassword]').css('display', 'none');
                                            $form.find('.form-item[rel=vCenterDatacenter]').css('display', 'none');
                                            $form.find('.form-item[rel=enableNexusVswitch]').css('display', 'none');

                                            $form.find('.form-item[rel=overridepublictraffic]').css('display', 'none');
                                            $form.find('.form-item[rel=overrideguesttraffic]').css('display', 'none');
                                            $nexusDvsOptFields.hide();
                                            $nexusDvsReqFields.hide();
                                        }

                                        if ($form.find('.form-item[rel=overridepublictraffic]').css('display') != 'none' && $overridePublicTraffic.is(':checked')) {
                                            $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'inline-block');
                                            $form.find('.form-item[rel=vSwitchPublicName]').css('display', 'inline-block');
                                        } else {
                                            $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'none');
                                            $form.find('.form-item[rel=vSwitchPublicName]').css('display', 'none');
                                        }

                                        if ($form.find('.form-item[rel=overrideguesttraffic]').css('display') != 'none' && $overrideGuestTraffic.is(':checked')) {
                                            $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'inline-block');
                                            $form.find('.form-item[rel=vSwitchGuestName]').css('display', 'inline-block');
                                        } else {
                                            $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'none');
                                            $form.find('.form-item[rel=vSwitchGuestName]').css('display', 'none');
                                        }
                                    });

                                    $form.trigger('click');
                                },
                                fields: {
                                    zoneid: {
                                        label: 'label.zone.name',
                                        docID: 'helpClusterZone',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            var data = args.context.zones ? {
                                                id: args.context.zones[0].id
                                            }: {};

                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: data,
                                                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
                                                            };
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    hypervisor: {
                                        label: 'label.hypervisor',
                                        docID: 'helpClusterHypervisor',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listHypervisors"),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    var hypervisors = json.listhypervisorsresponse.hypervisor;
                                                    var items =[];
                                                    $(hypervisors).each(function () {
                                                        items.push({
                                                            id: this.name,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    podId: {
                                        label: 'label.pod.name',
                                        docID: 'helpClusterPod',
                                        dependsOn: 'zoneid',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listPods&zoneid=" + args.zoneid),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var pods = json.listpodsresponse.pod;
                                                    var items =[];
                                                    $(pods).each(function () {
                                                        if (("pods" in args.context) && (this.id == args.context.pods[0].id))
                                                        items.unshift({
                                                            id: this.id,
                                                            description: this.name
                                                        }); else
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    name: {
                                        label: 'label.cluster.name',
                                        docID: 'helpClusterName',
                                        validation: {
                                            required: true
                                        }
                                    },

                                    isDedicated: {
                                        label: 'label.dedicate',
                                        isBoolean: true,
                                        isChecked: false,
                                        docID: 'helpDedicateResource'
                                    },

                                    domainId: {
                                        label: 'label.domain',
                                        isHidden: true,
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'isDedicated',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL('listDomains'),
                                                data: {
                                                    listAll: true,
                                                    details: 'min'
                                                },
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    var domainObjs = json.listdomainsresponse.domain;
                                                    var items =[];

                                                    $(domainObjs).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    items.sort(function(a, b) {
                                                        return a.description.localeCompare(b.description);
                                                    });

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

                                    accountId: {
                                        label: 'label.account',
                                        isHidden: true,
                                        dependsOn: 'isDedicated',
                                        docID: 'helpAccountForDedication',
                                        validation: {
                                            required: false
                                        }
                                    },

                                    //hypervisor==Ovm3 begins here
                                    ovm3pool: {
                                        label: 'label.ovm3.pool',
                                        isHidden: true,
                                        isBoolean: true,
                                        isChecked: true,
                                        docID: 'helpOvm3pool'
                                    },
                                    ovm3cluster: {
                                        label: 'label.ovm3.cluster',
                                        isHidden: true,
                                        isBoolean: true,
                                        isChecked: false,
                                        docID: 'helpOvm3cluster'
                                    },
                                    ovm3vip: {
                                        label: 'label.ovm3.vip',
                                        isHidden: true,
                                        docID: 'helpOvm3Vip',
                                        validation: {
                                            required: false
                                        }
                                    },

                                    //hypervisor==VMWare begins here
                                    vCenterHost: {
                                        label: 'label.vcenter.host',
                                        isHidden: true,
                                        docID: 'helpClustervCenterHost',
                                        validation: {
                                            required: false
                                        }
                                        //legacy zone - validation not required for new VMware dc model
                                    },
                                    vCenterUsername: {
                                        label: 'label.vcenter.username',
                                        isHidden: true,
                                        docID: 'helpClustervCenterUsername'
                                    },
                                    vCenterPassword: {
                                        label: 'label.vcenter.password',
                                        isHidden: true,
                                        docID: 'helpClustervCenterPassword',
                                        isPassword: true
                                    },
                                    vCenterDatacenter: {
                                        label: 'label.vcenter.datacenter',
                                        isHidden: true,
                                        docID: 'helpClustervCenterDatacenter',
                                        validation: {
                                            required: false
                                        }
                                        //legacy zone - validation not required for new VMware dc model
                                    },

                                    overridepublictraffic: {
                                        label: 'label.override.public.traffic',
                                        isBoolean: true,
                                        isHidden: true,
                                        isChecked: false,
                                        docID: 'helpOverridePublicNetwork'
                                    },


                                    vSwitchPublicType: {
                                        label: 'label.public.traffic.vswitch.type',
                                        select: function (args) {
                                            var useNexusDvs = false;
                                            var items =[]
                                            $.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) {
                                                items.push({
                                                    id: "nexusdvs",
                                                    description: "Cisco Nexus 1000v Distributed Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaresvs",
                                                    description: "VMware vNetwork Standard Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaredvs",
                                                    description: "VMware vNetwork Distributed Virtual Switch"
                                                });
                                            } else {
                                                items.push({
                                                    id: "vmwaredvs",
                                                    description: "VMware vNetwork Distributed Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaresvs",
                                                    description: "VMware vNetwork Standard Virtual Switch"
                                                });
                                                items.push({
                                                    id: "nexusdvs",
                                                    description: "Cisco Nexus 1000v Distributed Virtual Switch"
                                                });
                                            }

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

                                    vSwitchPublicName: {
                                        label: 'label.public.traffic.vswitch.name',
                                        isHidden: true
                                    },

                                    overrideguesttraffic: {
                                        label: 'label.override.guest.traffic',
                                        isBoolean: true,
                                        isHidden: true,
                                        isChecked: false,
                                        docID: 'helpOverrideGuestNetwork'
                                    },

                                    vSwitchGuestType: {
                                        label: 'label.guest.traffic.vswitch.type',
                                        select: function (args) {
                                            var items =[]

                                            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) {
                                                items.push({
                                                    id: "nexusdvs",
                                                    description: "Cisco Nexus 1000v Distributed Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaresvs",
                                                    description: "VMware vNetwork Standard Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaredvs",
                                                    description: "VMware vNetwork Distributed Virtual Switch"
                                                });
                                            } else {
                                                items.push({
                                                    id: "vmwaredvs",
                                                    description: "VMware vNetwork Distributed Virtual Switch"
                                                });
                                                items.push({
                                                    id: "vmwaresvs",
                                                    description: "VMware vNetwork Standard Virtual Switch"
                                                });
                                                items.push({
                                                    id: "nexusdvs",
                                                    description: "Cisco Nexus 1000v Distributed Virtual Switch"
                                                });
                                            }

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

                                    vSwitchGuestName: {
                                        label: 'label.guest.traffic.vswitch.name',
                                        isHidden: true
                                    },


                                    vsmipaddress: {
                                        label: 'label.cisco.nexus1000v.ip.address',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },
                                    vsmipaddress_req: {
                                        label: 'label.cisco.nexus1000v.ip.address',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    vsmusername: {
                                        label: 'label.cisco.nexus1000v.username',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },
                                    vsmusername_req: {
                                        label: 'label.cisco.nexus1000v.username',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    vsmpassword: {
                                        label: 'label.cisco.nexus1000v.password',
                                        validation: {
                                            required: false
                                        },
                                        isPassword: true,
                                        isHidden: true
                                    },
                                    vsmpassword_req: {
                                        label: 'label.cisco.nexus1000v.password',
                                        validation: {
                                            required: true
                                        },
                                        isPassword: true,
                                        isHidden: true
                                    }
                                    //hypervisor==VMWare ends here
                                }
                            },

                            action: function (args) {
                                var array1 =[];
                                array1.push("&zoneId=" + args.data.zoneid);
                                array1.push("&hypervisor=" + args.data.hypervisor);

                                var clusterType;
                                if (args.data.hypervisor == "VMware")
                                clusterType = "ExternalManaged"; else
                                clusterType = "CloudManaged";
                                array1.push("&clustertype=" + clusterType);

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

                                var clusterName = args.data.name;
                                if (args.data.hypervisor == "Ovm3") {
                                     array1.push("&ovm3pool=" + encodeURIComponent(args.data.ovm3pool));
                                     array1.push("&ovm3cluster=" + encodeURIComponent(args.data.ovm3cluster));
                                     array1.push("&ovm3vip=" + encodeURIComponent(args.data.ovm3vip));
                                }
                                if (args.data.hypervisor == "VMware") {
                                    cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.vCenterUsername, args.data.vCenterPassword);

                                    //vSwitch Public Type
                                    if (args.$form.find('.form-item[rel=vSwitchPublicType]').css('display') != 'none' && args.data.vSwitchPublicType != "") {
                                        array1.push("&publicvswitchtype=" + args.data.vSwitchPublicType);
                                    }
                                    if (args.$form.find('.form-item[rel=vSwitchPublicName]').css('display') != 'none' && args.data.vSwitchPublicName != "") {
                                        array1.push("&publicvswitchname=" + args.data.vSwitchPublicName);
                                    }

                                    //vSwitch Guest Type
                                    if (args.$form.find('.form-item[rel=vSwitchGuestType]').css('display') != 'none' && args.data.vSwitchGuestType != "") {
                                        array1.push("&guestvswitchtype=" + args.data.vSwitchGuestType);
                                    }
                                    if (args.$form.find('.form-item[rel=vSwitchGuestName]').css('display') != 'none' && args.data.vSwitchGuestName != "") {
                                        array1.push("&guestvswitchname=" + args.data.vSwitchGuestName);
                                    }

                                    //Nexus VSM fields
                                    if (args.$form.find('.form-item[rel=vsmipaddress]').css('display') != 'none' && args.data.vsmipaddress != null && args.data.vsmipaddress.length > 0) {
                                        array1.push('&vsmipaddress=' + args.data.vsmipaddress);
                                    }
                                    if (args.$form.find('.form-item[rel=vsmipaddress_req]').css('display') != 'none' && args.data.vsmipaddress_req != null && args.data.vsmipaddress_req.length > 0) {
                                        array1.push('&vsmipaddress=' + args.data.vsmipaddress_req);
                                    }

                                    if (args.$form.find('.form-item[rel=vsmusername]').css('display') != 'none' && args.data.vsmusername != null && args.data.vsmusername.length > 0) {
                                        array1.push('&vsmusername=' + args.data.vsmusername);
                                    }
                                    if (args.$form.find('.form-item[rel=vsmusername_req]').css('display') != 'none' && args.data.vsmusername_req != null && args.data.vsmusername_req.length > 0) {
                                        array1.push('&vsmusername=' + args.data.vsmusername_req);
                                    }

                                    if (args.$form.find('.form-item[rel=vsmpassword]').css('display') != 'none' && args.data.vsmpassword != null && args.data.vsmpassword.length > 0) {
                                        array1.push('&vsmpassword=' + args.data.vsmpassword);
                                    }
                                    if (args.$form.find('.form-item[rel=vsmpassword_req]').css('display') != 'none' && args.data.vsmpassword_req != null && args.data.vsmpassword_req.length > 0) {
                                        array1.push('&vsmpassword=' + args.data.vsmpassword_req);
                                    }


                                    var hostname = args.data.vCenterHost;
                                    var dcName = args.data.vCenterDatacenter;

                                    if (hostname.length == 0 && dcName.length == 0) {
                                        $.ajax({
                                            url: createURL('listVmwareDcs'),
                                            data: {
                                                zoneid: args.data.zoneid
                                            },
                                            async: false,
                                            success: function (json) {
                                                //e.g. json == { "listvmwaredcsresponse" { "count":1 ,"VMwareDC" [ {"id":"c3c2562d-65e9-4fc7-92e2-773c2efe8f37","zoneid":1,"name":"datacenter","vcenter":"10.10.20.20"} ] } }
                                                var vmwaredcs = json.listvmwaredcsresponse.VMwareDC;
                                                if (vmwaredcs != null) {
                                                    hostname = vmwaredcs[0].vcenter;
                                                    dcName = vmwaredcs[0].name;
                                                }
                                            }
                                        });
                                    }

                                    var url;
                                    if (hostname.indexOf("http://") == -1)
                                    url = "http://" + hostname; else
                                    url = hostname;
                                    url += "/" + dcName + "/" + clusterName;
                                    array1.push("&url=" + encodeURIComponent(url));

                                    clusterName = hostname + "/" + dcName + "/" + clusterName; //override clusterName
                                }
                                array1.push("&clustername=" + encodeURIComponent(clusterName));
                                var clusterId = null;
                                $.ajax({
                                    url: createURL("addCluster" + array1.join("")),
                                    dataType: "json",
                                    type: "POST",
                                    success: function (json) {
                                        var item = json.addclusterresponse.cluster[0];
                                        clusterId = json.addclusterresponse.cluster[0].id;

                                        //EXPLICIT DEDICATION
                                        var array2 =[];
                                        if (args.$form.find('.form-item[rel=isDedicated]').find('input[type=checkbox]').is(':Checked') == true) {
                                            if (args.data.accountId != "")
                                            array2.push("&account=" + encodeURIComponent(args.data.accountId));

                                            if (clusterId != null) {
                                                $.ajax({
                                                    url: createURL("dedicateCluster&clusterId=" + clusterId + "&domainId=" + args.data.domainId + array2.join("")),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var jid = json.dedicateclusterresponse.jobid;
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jid
                                                            },
                                                            notification: {
                                                                poll: pollAsyncJobResult,
                                                                interval: 4500,
                                                                desc: "Dedicate Cluster"
                                                            },

                                                            data: $.extend(item, {
                                                                state: 'Enabled'
                                                            })
                                                        });
                                                    },
                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                    }
                                                });
                                            }
                                        }
                                        args.response.success({
                                            data: item,
                                            actionFilter: clusterActionfilter
                                        });
                                    },
                                    error: function (XMLHttpResponse) {
                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                        args.response.error(errorMsg);
                                    }
                                });
                            }
                        },
                        viewMetrics: {
                            label: 'label.metrics',
                            isHeader: true,
                            addRow: false,
                            action: {
                                custom: cloudStack.uiCustom.metricsView({resource: 'clusters'})
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.metrics';
                                }
                            }
                        },
                        startRollingMaintenance: rollingMaintenanceAction({ listView: true, entity: 'clusters' })
                    },

                    detailView: {
                        viewAll: {
                            path: '_zone.hosts',
                            label: 'label.hosts'
                        },
                        isMaximized: true,
                        tabFilter: function (args) {
                            var vSwichConfigEnabled, vSwitchPresentOnCluster;
                            $.ajax({
                                url: createURL('listConfigurations'),
                                data: {
                                    name: 'vmware.use.nexus.vswitch'
                                },
                                async: false,
                                success: function (json) {
                                    vSwichConfigEnabled = json.listconfigurationsresponse.configuration[0].value;
                                }
                            });

                            var hypervisorType = args.context.clusters[0].hypervisortype;
                            if (vSwichConfigEnabled != "true" || hypervisorType != 'VMware') {
                                return[ 'nexusVswitch'];
                            }
                            return[];
                        },

                        actions: {

                            startRollingMaintenance: {
                                label: 'label.start.rolling.maintenance',
                                textLabel: 'label.start.rolling.maintenance',
                                messages: {
                                    notification: function (args) {
                                        return 'label.start.rolling.maintenance';
                                    }
                                },
                                createForm: {
                                    title: 'label.start.rolling.maintenance',
                                    fields: {
                                        timeout: {
                                            label: 'label.timeout',
                                        },
                                        force: {
                                            isBoolean: true,
                                            label: 'label.start.rolling.maintenance.force'
                                        },
                                        payload: {
                                            label: 'label.start.rolling.maintenance.payload'
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = {
                                        clusterids: args.context.clusters[0].id,
                                        force: args.data.force,
                                        timeout: args.data.timeout,
                                        payload: args.data.payload
                                    };
                                    $.ajax({
                                        url: createURL("startRollingMaintenance"),
                                        dataType: "json",
                                        data: data,
                                        async: true,
                                        success: function (json) {
                                            var item = json.rollingmaintenance;
                                            args.response.success({
                                                actionFilter: zoneActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },
                            edit: {
                                label: 'label.edit',
                                action: function (args) {
                                    var array1 =[];

                                    $.ajax({
                                        url: createURL("updateCluster&id=" + args.context.clusters[0].id + array1.join("")),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updateclusterresponse.cluster;
                                            addExtraPropertiesToClusterObject(item);
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                }
                            },

                            enable: {
                                label: 'label.action.enable.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.enable.cluster';
                                    },
                                    notification: function (args) {
                                        return 'label.action.enable.cluster';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateCluster&id=" + args.context.clusters[0].id + "&allocationstate=Enabled"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updateclusterresponse.cluster;
                                            args.context.clusters[0].state = item.allocationstate;
                                            addExtraPropertiesToClusterObject(item);
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            disable: {
                                label: 'label.action.disable.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.disable.cluster';
                                    },
                                    notification: function (args) {
                                        return 'label.action.disable.cluster';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateCluster&id=" + args.context.clusters[0].id + "&allocationstate=Disabled"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updateclusterresponse.cluster;
                                            args.context.clusters[0].state = item.allocationstate;
                                            addExtraPropertiesToClusterObject(item);
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            dedicate: {
                                label: 'label.dedicate.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.dedicate.cluster.domain.account';
                                    },
                                    notification: function (args) {
                                        return 'message.cluster.dedicated';
                                    }
                                },
                                createForm: {
                                    title: 'label.dedicate.cluster',
                                    fields: {
                                        domainId: {
                                            label: 'label.domain',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                $.ajax({
                                                    url: createURL('listDomains'),
                                                    data: {
                                                        listAll: true,
                                                        details: 'min'
                                                    },
                                                    dataType: "json",
                                                    async: false,
                                                    success: function (json) {
                                                        var domainObjs = json.listdomainsresponse.domain;
                                                        var items =[];

                                                        $(domainObjs).each(function () {
                                                            items.push({
                                                                id: this.id,
                                                                description: this.name
                                                            });
                                                        });
                                                        items.sort(function(a, b) {
                                                            return a.description.localeCompare(b.description);
                                                        });

                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                });
                                            }
                                        },
                                        accountId: {
                                            label: 'label.account',
                                            docID: 'helpAccountForDedication',
                                            validation: {
                                                required: false
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    //EXPLICIT DEDICATION
                                    var array2 =[];
                                    if (args.data.accountId != "")
                                    array2.push("&account=" + encodeURIComponent(args.data.accountId));
                                    $.ajax({
                                        url: createURL("dedicateCluster&clusterId=" +
                                        args.context.clusters[0].id +
                                        "&domainId=" + args.data.domainId + array2.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.dedicateclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            release: {
                                label: 'label.release.dedicated.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.release.dedicated.cluster';
                                    },
                                    notification: function (args) {
                                        return 'message.cluster.dedication.released';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("releaseDedicatedCluster&clusterid=" + args.context.clusters[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.releasededicatedclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },


                            manage: {
                                label: 'label.action.manage.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.manage.cluster';
                                    },
                                    notification: function (args) {
                                        return 'label.action.manage.cluster';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateCluster&id=" + args.context.clusters[0].id + "&managedstate=Managed"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updateclusterresponse.cluster;
                                            addExtraPropertiesToClusterObject(item);
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            unmanage: {
                                label: 'label.action.unmanage.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.unmanage.cluster';
                                    },
                                    notification: function (args) {
                                        return 'label.action.unmanage.cluster';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("updateCluster&id=" + args.context.clusters[0].id + "&managedstate=Unmanaged"),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.updateclusterresponse.cluster;
                                            addExtraPropertiesToClusterObject(item);
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            'remove': {
                                label: 'label.action.delete.cluster',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.delete.cluster';
                                    },
                                    notification: function (args) {
                                        return 'label.action.delete.cluster';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("deleteCluster&id=" + args.context.clusters[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            args.response.success({
                                                data: {
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            enableOutOfBandManagement: {
                                label: 'label.outofbandmanagement.enable',
                                action: function (args) {
                                    var data = {
                                        clusterid: args.context.clusters[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("enableOutOfBandManagementForCluster"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.enableoutofbandmanagementforclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.enable';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.enable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            disableOutOfBandManagement: {
                                label: 'label.outofbandmanagement.disable',
                                action: function (args) {
                                    var data = {
                                        clusterid: args.context.clusters[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("disableOutOfBandManagementForCluster"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.disableoutofbandmanagementforclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }

                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.disable';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.disable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            enableHA: {
                                label: 'label.ha.enable',
                                action: function (args) {
                                    var data = {
                                        clusterid: args.context.clusters[0].id
                                    };
                                    $.ajax({
                                        url: createURL("enableHAForCluster"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.enablehaforclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'label.ha.enable';
                                    },
                                    notification: function (args) {
                                        return 'label.ha.enable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            disableHA: {
                                label: 'label.ha.disable',
                                action: function (args) {
                                    var data = {
                                        clusterid: args.context.clusters[0].id
                                    };
                                    $.ajax({
                                        url: createURL("disableHAForCluster"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.disablehaforclusterresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return clusterActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'label.ha.disable';
                                    },
                                    notification: function (args) {
                                        return 'label.ha.disable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }
                        },

                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    zonename: {
                                        label: 'label.zone'
                                    },
                                    podname: {
                                        label: 'label.pod'
                                    },
                                    hypervisortype: {
                                        label: 'label.hypervisor'
                                    },
                                    clustertype: {
                                        label: 'label.cluster.type'
                                    },
                                    //allocationstate: { label: 'label.allocation.state' },
                                    //managedstate: { label: 'Managed State' },
                                    state: {
                                        label: 'label.state'
                                    }
                                }, {
                                    isdedicated: {
                                        label: 'label.dedicated'
                                    },
                                    domainid: {
                                        label: 'label.domain.id'
                                    }
                                }],
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listClusters&id=" + args.context.clusters[0].id),
                                        dataType: "json",
                                        success: function (json) {
                                            var item = json.listclustersresponse.cluster[0];
                                            addExtraPropertiesToClusterObject(item);
                                            $.ajax({
                                                url: createURL("listDedicatedClusters&clusterid=" + args.context.clusters[0].id),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    if (json.listdedicatedclustersresponse.dedicatedcluster != undefined) {
                                                        var clusterItem = json.listdedicatedclustersresponse.dedicatedcluster[0];
                                                        if (clusterItem.domainid != null) {
                                                            $.extend(item, clusterItem, {
                                                                isdedicated: _l('label.yes')
                                                            });
                                                        }
                                                    } else
                                                    $.extend(item, {
                                                        isdedicated: _l('label.no')
                                                    })
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                }
                                            });
                                            args.response.success({
                                                actionFilter: clusterActionfilter,
                                                data: item
                                            });
                                        },

                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                        }
                                    });
                                }
                            },
                            nexusVswitch: {
                                title: 'label.nexusVswitch',
                                listView: {
                                    id: 'vSwitches',
                                    fields: {
                                        vsmdeviceid: {
                                            label: 'label.name'
                                        },
                                        vsmdevicestate: {
                                            label: 'label.state',
                                            indicator: {
                                                'Enabled': 'on'
                                            }
                                        }
                                    },
                                    detailView: {
                                        actions: {
                                            enable: {
                                                label: 'label.action.enable.nexusVswitch',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.enable.nexusVswitch';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.enable.nexusVswitch';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("enableCiscoNexusVSM&id=" + args.context.vSwitches[0].vsmdeviceid),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.enablecisconexusvsmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                            //args.context.vSwitches[0].vsmdevicestate = item.allocationstate;
                                                            //addExtraPropertiesToClusterObject(item);
                                                            args.response.success({
                                                                actionFilter: nexusActionfilter,
                                                                data: item
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: function (args) {
                                                        args.complete();
                                                    }
                                                }
                                            },

                                            disable: {
                                                label: 'label.action.disable.nexusVswitch',
                                                messages: {
                                                    confirm: function (args) {
                                                        return 'message.action.disable.nexusVswitch';
                                                    },
                                                    notification: function (args) {
                                                        return 'label.action.disable.nexusVswitch';
                                                    }
                                                },
                                                action: function (args) {
                                                    $.ajax({
                                                        url: createURL("disableCiscoNexusVSM&id=" + args.context.vSwitches[0].vsmdeviceid),
                                                        dataType: "json",
                                                        async: true,
                                                        success: function (json) {
                                                            var jid = json.disablecisconexusvsmresponse.jobid;
                                                            args.response.success({
                                                                _custom: {
                                                                    jobId: jid
                                                                }
                                                            });
                                                            //args.context.vSwitches[0].vsmdevicestate = item.allocationstate;
                                                            //addExtraPropertiesToClusterObject(item);
                                                            args.response.success({
                                                                actionFilter: nexusActionfilter,
                                                                data: item
                                                            });
                                                        }
                                                    });
                                                },
                                                notification: {
                                                    poll: function (args) {
                                                        args.complete();
                                                    }
                                                }
                                            }

                                            /*   'remove': {
                                            label: 'label.action.delete.nexusVswitch' ,
                                            messages: {
                                            confirm: function(args) {
                                            return 'message.action.delete.nexusVswitch';
                                            },
                                            notification: function(args) {
                                            return 'label.action.delete.nexusVswitch';
                                            }
                                            },
                                            action: function(args) {
                                            $.ajax({
                                            url: createURL("deleteCiscoNexusVSM&id=" + args.context.vSwitches[0].vsmdeviceid),
                                            dataType: "json",
                                            async: true,
                                            success: function(json) {
                                            args.response.success({data:{}});
                                            }
                                            });
                                            },
                                            notification: {
                                            poll: function(args) { args.complete(); }
                                            }
                                            }*/
                                        },

                                        tabs: {
                                            details: {
                                                title: 'label.details',
                                                fields: {
                                                    vsmdeviceid: {
                                                        label: 'label.name'
                                                    },
                                                    ipaddress: {
                                                        label: 'label.ipaddress'
                                                    },
                                                    vsmctrlvlanid: {
                                                        label: 'label.vsmctrlvlanid'
                                                    },
                                                    vsmpktvlanid: {
                                                        label: 'label.vsmpktvlanid'
                                                    },
                                                    vsmstoragevlanid: {
                                                        label: 'label.vsmstoragevlanid'
                                                    },
                                                    vsmdevicestate: {
                                                        label: 'label.state',
                                                        indicator: {
                                                            'Enabled': 'on'
                                                        }
                                                    }
                                                },

                                                dataProvider: function (args) {
                                                    $.ajax({
                                                        url: createURL("listCiscoNexusVSMs&clusterid=" + args.context.clusters[0].id),
                                                        dataType: "json",
                                                        success: function (json) {
                                                            var item = json.listcisconexusvsmscmdresponse.cisconexusvsm[0];
                                                            addExtraPropertiesToClusterObject(item);
                                                            args.response.success({
                                                                actionFilter: nexusActionfilter,
                                                                data: item
                                                            });
                                                        },
                                                        error: function (json) {
                                                            args.response.error(parseXMLHttpResponse(json));
                                                        }
                                                    });
                                                }
                                            }
                                        }
                                    },

                                    dataProvider: function (args) {
                                        $.ajax({
                                            url: createURL("listCiscoNexusVSMs&clusterid=" + args.context.clusters[0].id),
                                            dataType: "json",
                                            success: function (json) {
                                                var item = json.listcisconexusvsmscmdresponse.cisconexusvsm;
                                                args.response.success({
                                                    actionFilter: nexusActionfilter,
                                                    data: item
                                                });
                                            },
                                            error: function (json) {
                                                // Not generally a real error; means vSwitch still needs setup
                                                args.response.success({
                                                    data:[]
                                                });
                                            }
                                        });
                                    }
                                }
                            },

                            // Granular settings for cluster
                            settings: {
                                title: 'label.settings',
                                custom: cloudStack.uiCustom.granularSettings({
                                    dataProvider: function (args) {
                                        $.ajax({
                                            url: createURL('listConfigurations&clusterid=' + args.context.clusters[0].id),
                                            data: listViewDataProvider(args, {
                                            },
                                            {
                                                searchBy: 'name'
                                            }),
                                            success: function (json) {
                                                args.response.success({
                                                    data: json.listconfigurationsresponse.configuration
                                                });
                                            },

                                            error: function (json) {
                                                args.response.error(parseXMLHttpResponse(json));
                                            }
                                        });
                                    },
                                    actions: {
                                        edit: function (args) {
                                            // call updateClusterLevelParameters

                                            var data = {
                                                name: args.data.jsonObj.name,
                                                value: args.data.value
                                            };

                                            $.ajax({
                                                url: createURL('updateConfiguration&clusterid=' + args.context.clusters[0].id),
                                                data: data,
                                                success: function (json) {
                                                    var item = json.updateconfigurationresponse.configuration;

                                                    if (args.data.jsonObj.name == 'cpu.overprovisioning.factor' || args.data.jsonObj.name == 'mem.overprovisioning.factor') {
                                                        cloudStack.dialog.notice({
                                                            message: 'Please note - if you are changing the over provisioning factor for a cluster with vms running, please refer to the admin guide to understand the capacity calculation.'
                                                        });
                                                    }

                                                    args.response.success({
                                                        data: item
                                                    });
                                                },

                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        }
                                    }
                                })
                            }
                        }
                    }
                }
            },
            hosts: {
                title: 'label.hosts',
                id: 'hosts',
                listView: {
                    section: 'hosts',
                    id: 'hosts',
                    multiSelect: true,
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        ipaddress: {
                            label: 'label.ip.address'
                        },
                        hypervisor: {
                            label: 'label.hypervisor'
                        },
                        zonename: {
                            label: 'label.zone'
                        },
                        clustername: {
                            label: 'label.cluster'
                        },
                        resourcestate: {
                            label: 'label.resource.state',
                            indicator: {
                                'Enabled': 'on',
                                'Disabled': 'off',
                                'Maintenance': 'warning'
                            }
                        },
                        state: {
                            label: 'label.state',
                            indicator: {
                                'Up': 'on',
                                'Down': 'off',
                                'Disconnected': 'off',
                                'Alert': 'off',
                                'Error': 'off',
                                'Unsecure': 'warning'
                            }
                        },
                        powerstate: {
                            label: 'label.powerstate',
                            indicator: {
                                'On': 'on',
                                'Off': 'off',
                                'Unknown': 'warning'
                            },
                        },
                    },

                    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;
                                }
                            }
                        }

                        if (! args.context.instances) {
                            if ("zones" in args.context)
                                array1.push("&zoneid=" + args.context.zones[0].id);
                            if ("pods" in args.context)
                                array1.push("&podid=" + args.context.pods[0].id);
                            if ("clusters" in args.context)
                               array1.push("&clusterid=" + args.context.clusters[0].id);
                        } else {
                            //Instances menu > Instance detailView > View Hosts
                            array1.push("&id=" + args.context.instances[0].hostid);
                        }
                        $.ajax({
                            url: createURL("listHosts&type=Routing" + array1.join("") + "&page=" + args.page + "&pagesize=" + pageSize),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.listhostsresponse.host;
                                if (items) {
                                    $.each(items, function(idx, host) {
                                        if (host && host.outofbandmanagement) {
                                            items[idx].powerstate = host.outofbandmanagement.powerstate;
                                        }

                                        if (host && host.hypervisor == "KVM" && host.state == 'Up' && host.details && host.details["secured"] != 'true') {
                                            items[idx].state = 'Unsecure';
                                        }
                                    });
                                }

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

                    actions: {
                        add: {
                            label: 'label.add.host',

                            createForm: {
                                title: 'label.add.host',
                                fields: {
                                    zoneid: {
                                        docID: 'helpHostZone',
                                        label: 'label.zone',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            var data = args.context.zones ? {
                                                id: args.context.zones[0].id
                                            }: {};

                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: data,
                                                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
                                                            };
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    //always appear (begin)
                                    podId: {
                                        label: 'label.pod',
                                        docID: 'helpHostPod',
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'zoneid',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listPods&zoneid=" + args.zoneid),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var pods = json.listpodsresponse.pod;
                                                    var items =[];
                                                    $(pods).each(function () {
                                                        if (("pods" in args.context) && (this.id == args.context.pods[0].id))
                                                        items.unshift({
                                                            id: this.id,
                                                            description: this.name
                                                        }); else
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    clusterId: {
                                        label: 'label.cluster',
                                        docID: 'helpHostCluster',
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'podId',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listClusters&podid=" + args.podId),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    clusterObjs = json.listclustersresponse.cluster;
                                                    var items =[];
                                                    $(clusterObjs).each(function () {
                                                        if (("clusters" in args.context) && (this.id == args.context.clusters[0].id))
                                                        items.unshift({
                                                            id: this.id,
                                                            description: this.name
                                                        }); else
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });

                                            args.$select.change(function () {
                                                var $form = $(this).closest('form');

                                                var clusterId = $(this).val();
                                                if (clusterId == null)
                                                return;

                                                var items =[];
                                                $(clusterObjs).each(function () {
                                                    if (this.id == clusterId) {
                                                        selectedClusterObj = this;
                                                        return false; //break the $.each() loop
                                                    }
                                                });
                                                if (selectedClusterObj == null)
                                                return;

                                                if (selectedClusterObj.hypervisortype == "VMware") {
                                                    //$('li[input_group="general"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=hostname]').hide();
                                                    $form.find('.form-item[rel=username]').hide();
                                                    $form.find('.form-item[rel=password]').hide();

                                                    //$('li[input_group="vmware"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=vcenterHost]').css('display', 'inline-block');

                                                    //$('li[input_group="baremetal"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=baremetalCpuCores]').hide();
                                                    $form.find('.form-item[rel=baremetalCpu]').hide();
                                                    $form.find('.form-item[rel=baremetalMemory]').hide();
                                                    $form.find('.form-item[rel=baremetalMAC]').hide();

                                                    //$('li[input_group="Ovm"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();

                                                    //$('li[input_group="Ovm3"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();
                                                    $form.find('.form-item[rel=agentPort]').hide();
                                                    $form.find('.form-item[rel=ovm3vip]').hide();
                                                    $form.find('.form-item[rel=ovm3pool]').hide();
                                                    $form.find('.form-item[rel=ovm3cluster]').hide();
                                                } else if (selectedClusterObj.hypervisortype == "BareMetal") {
                                                    //$('li[input_group="general"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=hostname]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=username]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=password]').css('display', 'inline-block');

                                                    //$('li[input_group="baremetal"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=baremetalCpuCores]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=baremetalCpu]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=baremetalMemory]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=baremetalMAC]').css('display', 'inline-block');

                                                    //$('li[input_group="vmware"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=vcenterHost]').hide();

                                                    //$('li[input_group="Ovm"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();

                                                    //$('li[input_group="Ovm3"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();
                                                    $form.find('.form-item[rel=agentPort]').hide();
                                                    $form.find('.form-item[rel=ovm3vip]').hide();
                                                    $form.find('.form-item[rel=ovm3pool]').hide();
                                                    $form.find('.form-item[rel=ovm3cluster]').hide();
                                                } else if (selectedClusterObj.hypervisortype == "Ovm") {
                                                    //$('li[input_group="general"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=hostname]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=username]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=password]').css('display', 'inline-block');

                                                    //$('li[input_group="vmware"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=vcenterHost]').hide();

                                                    //$('li[input_group="baremetal"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=baremetalCpuCores]').hide();
                                                    $form.find('.form-item[rel=baremetalCpu]').hide();
                                                    $form.find('.form-item[rel=baremetalMemory]').hide();
                                                    $form.find('.form-item[rel=baremetalMAC]').hide();

                                                    //$('li[input_group="Ovm"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=agentUsername]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=agentUsername]').find('input').val("oracle");
                                                    $form.find('.form-item[rel=agentPassword]').css('display', 'inline-block');

                                                    //$('li[input_group="Ovm3"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();
                                                    $form.find('.form-item[rel=agentPort]').hide();
                                                    $form.find('.form-item[rel=ovm3vip]').hide();
                                                    $form.find('.form-item[rel=ovm3pool]').hide();
                                                    $form.find('.form-item[rel=ovm3cluster]').hide();
                                                } else if (selectedClusterObj.hypervisortype == "Ovm3") {
                                                    //$('li[input_group="general"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=hostname]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=username]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=password]').css('display', 'inline-block');

                                                    //$('li[input_group="vmware"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=vcenterHost]').hide();

                                                    //$('li[input_group="baremetal"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=baremetalCpuCores]').hide();
                                                    $form.find('.form-item[rel=baremetalCpu]').hide();
                                                    $form.find('.form-item[rel=baremetalMemory]').hide();
                                                    $form.find('.form-item[rel=baremetalMAC]').hide();

                                                     //$('li[input_group="Ovm3"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=agentUsername]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=agentUsername]').find('input').val("oracle");
                                                    $form.find('.form-item[rel=agentPassword]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=agentPort]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=agentPort]').find('input').val("8899");
                                                    $form.find('.form-item[rel=ovm3vip]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=ovm3pool]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=ovm3cluster]').css('display', 'inline-block');
                                                } else {
                                                    //$('li[input_group="general"]', $dialogAddHost).show();
                                                    $form.find('.form-item[rel=hostname]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=username]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=password]').css('display', 'inline-block');

                                                    //$('li[input_group="vmware"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=vcenterHost]').hide();

                                                    //$('li[input_group="baremetal"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=baremetalCpuCores]').hide();
                                                    $form.find('.form-item[rel=baremetalCpu]').hide();
                                                    $form.find('.form-item[rel=baremetalMemory]').hide();
                                                    $form.find('.form-item[rel=baremetalMAC]').hide();

                                                    //$('li[input_group="Ovm"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();

                                                    //$('li[input_group="Ovm3"]', $dialogAddHost).hide();
                                                    $form.find('.form-item[rel=agentUsername]').hide();
                                                    $form.find('.form-item[rel=agentPassword]').hide();
                                                    $form.find('.form-item[rel=agentPort]').hide();
                                                    $form.find('.form-item[rel=ovm3vip]').hide();
                                                    $form.find('.form-item[rel=ovm3pool]').hide();
                                                    $form.find('.form-item[rel=ovm3cluster]').hide();
                                                }
                                            });

                                            args.$select.trigger("change");
                                        }
                                    },
                                    //always appear (end)

                                    //input_group="general" starts here
                                    hostname: {
                                        label: 'label.host.name',
                                        docID: 'helpHostName',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    username: {
                                        label: 'label.username',
                                        docID: 'helpHostUsername',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    password: {
                                        label: 'label.password',
                                        docID: 'helpHostPassword',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true,
                                        isPassword: true
                                    },

                                    isDedicated: {
                                        label: 'label.dedicate',
                                        isBoolean: true,
                                        isChecked: false,
                                        docID: 'helpDedicateResource'
                                    },

                                    domainId: {
                                        label: 'label.domain',
                                        isHidden: true,
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'isDedicated',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL('listDomains'),
                                                data: {
                                                    listAll: true,
                                                    details: 'min'
                                                },
                                                dataType: "json",
                                                success: function (json) {
                                                    var domainObjs = json.listdomainsresponse.domain;
                                                    var items =[];

                                                    $(domainObjs).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    items.sort(function(a, b) {
                                                        return a.description.localeCompare(b.description);
                                                    });

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

                                    accountId: {
                                        label: 'label.account',
                                        isHidden: true,
                                        dependsOn: 'isDedicated',
                                        docID: 'helpAccountForDedication',
                                        validation: {
                                            required: false
                                        }
                                    },

                                    //input_group="general" ends here

                                    //input_group="VMWare" starts here
                                    vcenterHost: {
                                        label: 'label.esx.host',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    //input_group="VMWare" ends here

                                    //input_group="BareMetal" starts here
                                    baremetalCpuCores: {
                                        label: 'label.num.cpu.cores',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    baremetalCpu: {
                                        label: 'label.cpu.mhz',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    baremetalMemory: {
                                        label: 'label.memory.mb',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    baremetalMAC: {
                                        label: 'label.host.MAC',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    //input_group="BareMetal" ends here

                                    //input_group="OVM" starts here
                                    agentUsername: {
                                        label: 'label.agent.username',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },
                                    agentPassword: {
                                        label: 'label.agent.password',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true,
                                        isPassword: true
                                    },
                                    //input_group="OVM" ends here

                                    //input_group="OVM3" starts here
                                    agentPort: {
                                        label: 'label.agent.port',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },
                                    //input_group="OVM3" ends here

                                    //always appear (begin)
                                    hosttags: {
                                        label: 'label.host.tags',
                                        isTokenInput: true,
                                        docID: 'helpHostTags',
                                        validation: {
                                            required: false
                                        },
                                        dataProvider: function(args) {
                                            $.ajax({
                                                url: createURL("listHostTags"),
                                                dataType: "json",
                                                success: function(json) {
                                                    var item = json.listhosttagsresponse.hosttag;
                                                    var tags = [];

                                                    if (item != null)
                                                    {
                                                        tags = $.map(item, function(tag) {
                                                            return {
                                                                       id: tag.name,
                                                                       name: tag.name
                                                                   };
                                                        });
                                                    }

                                                    args.response.success({
                                                        data: tags,
                                                        hintText: _l('hint.type.part.host.tag'),
                                                        noResultsText: _l('hint.no.host.tags')
                                                    });
                                                },
                                                error: function(XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        }
                                    }
                                    //always appear (end)
                                }
                            },

                            action: function (args) {
                                var data = {
                                    zoneid: args.data.zoneid,
                                    podid: args.data.podId,
                                    clusterid: args.data.clusterId,
                                    hypervisor: selectedClusterObj.hypervisortype,
                                    clustertype: selectedClusterObj.clustertype,
                                    hosttags: args.data.hosttags
                                };

                                if (selectedClusterObj.hypervisortype == "VMware") {
                                    $.extend(data, {
                                        username: '',
                                        password: ''
                                    });

                                    var hostname = args.data.vcenterHost;
                                    var url;
                                    if (hostname.indexOf("http://") == -1)
                                    url = "http://" + hostname; else
                                    url = hostname;

                                    $.extend(data, {
                                        url: url
                                    });
                                } else {
                                    $.extend(data, {
                                        username: args.data.username,
                                        password: args.data.password
                                    });

                                    var hostname = args.data.hostname;
                                    var url;
                                    if (hostname.indexOf("http://") == -1)
                                    url = "http://" + hostname; else
                                    url = hostname;

                                    $.extend(data, {
                                        url: url
                                    });

                                    if (selectedClusterObj.hypervisortype == "BareMetal") {
                                        $.extend(data, {
                                            cpunumber: args.data.baremetalCpuCores,
                                            cpuspeed: args.data.baremetalCpu,
                                            memory: args.data.baremetalMemory,
                                            hostmac: args.data.baremetalMAC
                                        });
                                    } else if (selectedClusterObj.hypervisortype == "Ovm") {
                                        $.extend(data, {
                                            agentusername: args.data.agentUsername,
                                            agentpassword: args.data.agentPassword
                                        });
                                    } else if (selectedClusterObj.hypervisortype == "Ovm3") {
                                        $.extend(data, {
                                            agentusername: args.data.agentUsername,
                                            agentpassword: args.data.agentPassword,
                                            agentport: args.data.agentPort
                                       });
                                    }
                                }

                                var hostId = null;
                                $.ajax({
                                    url: createURL("addHost"),
                                    type: "POST",
                                    data: data,
                                    success: function (json) {
                                        var item = json.addhostresponse.host[0];

                                        hostId = json.addhostresponse.host[0].id;

                                        //EXPLICIT DEDICATION
                                        var array2 =[];

                                        if (args.$form.find('.form-item[rel=isDedicated]').find('input[type=checkbox]').is(':Checked') == true) {
                                            if (args.data.accountId != "")
                                            array2.push("&account=" + encodeURIComponent(args.data.accountId));


                                            if (hostId != null) {
                                                $.ajax({
                                                    url: createURL("dedicateHost&hostId=" + hostId + "&domainId=" + args.data.domainId + array2.join("")),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var jid = json.dedicatehostresponse.jobid;
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jid
                                                            },
                                                            notification: {
                                                                poll: pollAsyncJobResult,
                                                                interval: 4500,
                                                                desc: "Dedicate Host"
                                                            },

                                                            data: item
                                                        });
                                                    },

                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                    }
                                                });
                                            }
                                        }
                                        args.response.success({
                                            data: item
                                        });
                                    },

                                    error: function (XMLHttpResponse) {
                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                        args.response.error(errorMsg);
                                    }
                                });
                            },

                            notification: {
                                poll: function (args) {
                                    args.complete({
                                        actionFilter: hostActionfilter
                                    });
                                }
                            },

                            messages: {
                                notification: function (args) {
                                    return 'label.add.host';
                                }
                            }
                        },
                        viewMetrics: {
                            label: 'label.metrics',
                            isHeader: true,
                            addRow: false,
                            action: {
                                custom: cloudStack.uiCustom.metricsView({resource: 'hosts'})
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.metrics';
                                }
                            }
                        },
                        startRollingMaintenance: rollingMaintenanceAction({ listView: true, entity: 'hosts' })
                    },
                    detailView: {
                        name: "Host details",
                        viewAll: {
                            label: 'label.instances',
                            path: 'instances'
                        },
                        actions: {
                            startRollingMaintenance: {
                                label: 'label.start.rolling.maintenance',
                                textLabel: 'label.start.rolling.maintenance',
                                messages: {
                                    notification: function (args) {
                                        return 'label.start.rolling.maintenance';
                                    }
                                },
                                createForm: {
                                    title: 'label.start.rolling.maintenance',
                                    fields: {
                                        timeout: {
                                            label: 'label.timeout',
                                        },
                                        force: {
                                            isBoolean: true,
                                            label: 'label.start.rolling.maintenance.force'
                                        },
                                        payload: {
                                            label: 'label.start.rolling.maintenance.payload'
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = {
                                        hostids: args.context.hosts[0].id,
                                        force: args.data.force,
                                        timeout: args.data.timeout,
                                        payload: args.data.payload
                                    };
                                    $.ajax({
                                        url: createURL("startRollingMaintenance"),
                                        dataType: "json",
                                        data: data,
                                        async: true,
                                        success: function (json) {
                                            var item = json.rollingmaintenance;
                                            args.response.success({
                                                actionFilter: zoneActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },
                            edit: {
                                label: 'label.edit',
                                action: function (args) {
                                    var array1 =[];
                                    array1.push("&hosttags=" + encodeURIComponent(args.data.hosttags));

                                    if (args.data.oscategoryid != null && args.data.oscategoryid.length > 0)
                                        array1.push("&osCategoryId=" + args.data.oscategoryid);

                                    if (args.data.annotation != null && args.data.annotation.length > 0)
                                        array1.push("&annotation=" + args.data.annotation);

                                    if (args.data.name != null && args.data.name.length > 0)
                                        array1.push("&name=" + args.data.name);
                                    $.ajax({
                                        url: createURL("updateHost&id=" + args.context.hosts[0].id + array1.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var item = json.updatehostresponse.host;
                                            args.response.success({
                                                actionFilter: hostActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                }
                            },


                            dedicate: {
                                label: 'label.dedicate.host',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.dedicate.host.domain.account';
                                    },
                                    notification: function (args) {
                                        return 'message.host.dedicated';
                                    }
                                },
                                createForm: {
                                    title: 'label.dedicate.host',
                                    fields: {
                                        domainId: {
                                            label: 'label.domain',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                $.ajax({
                                                    url: createURL('listDomains'),
                                                    data: {
                                                        listAll: true,
                                                        details: 'min'
                                                    },
                                                    dataType: "json",
                                                    async: false,
                                                    success: function (json) {
                                                        var domainObjs = json.listdomainsresponse.domain;
                                                        var items =[];

                                                        $(domainObjs).each(function () {
                                                            items.push({
                                                                id: this.id,
                                                                description: this.name
                                                            });
                                                        });
                                                        items.sort(function(a, b) {
                                                            return a.description.localeCompare(b.description);
                                                        });

                                                        args.response.success({
                                                            data: items
                                                        });
                                                    }
                                                });
                                            }
                                        },
                                        accountId: {
                                            label: 'label.account',
                                            docID: 'helpAccountForDedication',
                                            validation: {
                                                required: false
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    //EXPLICIT DEDICATION
                                    var array2 =[];
                                    if (args.data.accountId != "")
                                    array2.push("&account=" + encodeURIComponent(args.data.accountId));

                                    $.ajax({
                                        url: createURL("dedicateHost&hostId=" +
                                        args.context.hosts[0].id +
                                        "&domainId=" + args.data.domainId + array2.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var jid = json.dedicatehostresponse.jobid;

                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },
                            release: {
                                label: 'label.release.dedicated.host',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.release.dedicated.host';
                                    },
                                    notification: function (args) {
                                        return 'message.host.dedication.released';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("releaseDedicatedHost&hostid=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.releasededicatedhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            secureKVMHost: {
                                label: 'label.action.secure.host',
                                action: function(args) {
                                    var data = {
                                        hostid: args.context.hosts[0].id
                                    };
                                    $.ajax({
                                        url: createURL('provisionCertificate'),
                                        data: data,
                                        async: true,
                                        success: function(json) {
                                            args.response.success({
                                                _custom: {
                                                    jobId: json.provisioncertificateresponse.jobid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.secure.host';
                                    },
                                    notification: function (args) {
                                        return 'label.action.secure.host';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            enableMaintenanceMode: {
                                label: 'label.action.enable.maintenance.mode',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("prepareHostForMaintenance&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.preparehostformaintenanceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.host;
                                                    },
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.host.enable.maintenance.mode';
                                    },
                                    notification: function (args) {
                                        return 'label.action.enable.maintenance.mode';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            cancelMaintenanceMode: {
                                label: 'label.action.cancel.maintenance.mode',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("cancelHostMaintenance&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.cancelhostmaintenanceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.host;
                                                    },
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.cancel.maintenance.mode';
                                    },
                                    notification: function (args) {
                                        return 'label.action.cancel.maintenance.mode';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            forceReconnect: {
                                label: 'label.action.force.reconnect',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("reconnectHost&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.reconnecthostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.host;
                                                    },
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.action.force.reconnect';
                                    },
                                    notification: function (args) {
                                        return 'label.action.force.reconnect';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            enable: {
                                label: 'label.enable.host',
                                action: function (args) {
                                    var data = {
                                         id: args.context.hosts[0].id,
                                         allocationstate: "Enable"
                                    };
                                    $.ajax({
                                        url: createURL("updateHost"),
                                        data: data,
                                        success: function (json) {
                                            var item = json.updatehostresponse.host;
                                            args.response.success({
                                                actionFilter: hostActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.enable.host';
                                    },
                                    notification: function (args) {
                                        return 'label.enable.host';
                                    }
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            disable: {
                                label: 'label.disable.host',
                                action: function (args) {
                                    var data = {
                                         id: args.context.hosts[0].id,
                                         allocationstate: "Disable"
                                    };
                                    $.ajax({
                                        url: createURL("updateHost"),
                                        data: data,
                                        success: function (json) {
                                            var item = json.updatehostresponse.host;
                                            args.response.success({
                                                actionFilter: hostActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.disable.host';
                                    },
                                    notification: function (args) {
                                        return 'label.disable.host';
                                    }
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            'remove': {
                                label: 'label.action.remove.host',
                                messages: {
                                    notification: function (args) {
                                        return 'label.action.remove.host';
                                    }
                                },
                                createForm: {
                                    title: 'label.action.remove.host',
                                    desc: 'message.action.remove.host',
                                    preFilter: function(args) { //bug to fix: preFilter is not picked up from here
                                        if (!isAdmin()) {
                                            args.$form.find('.form-item[rel=isForced]').hide();
                                        }
                                    },
                                    fields: {
                                        isForced: {
                                            label: 'force.remove',
                                            isBoolean: true,
                                            isHidden: false
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = {
                                        id: args.context.hosts[0].id
                                    };
                                    if(args.$form.find('.form-item[rel=isForced]').css("display") != "none") {
                                        $.extend(data, {
                                            forced: (args.data.isForced == "on")
                                        });
                                    }

                                    $.ajax({
                                        url: createURL("deleteHost"),
                                        data: data,
                                        success: function (json) {
                                            //{ "deletehostresponse" : { "success" : "true"}  }
                                            args.response.success({
                                                data: {
                                                }
                                            });

                                            if (args.context.hosts[0].hypervisor == "XenServer") {
                                                cloudStack.dialog.notice({ message: _s("The host has been removed. Please eject the host from the XenServer Resource Pool.") })
                                            }
                                            else if (args.context.hosts[0].hypervisor == "VMware") {
                                                cloudStack.dialog.notice({ message: _s("The host has been removed. Please eject the host from the vSphere Cluster.") })
                                            }
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            blankHAForHost: {
                                label: '',
                                action: function (args) {
                                }
                            },

                            configureHAForHost: {
                                label: 'label.ha.configure',
                                messages: {
                                    confirm: function (args) {
                                        return 'label.ha.configure';
                                    },
                                    notification: function (args) {
                                        return 'label.ha.configure';
                                    }
                                },
                                createForm: {
                                    title: 'label.ha.configure',
                                    fields: {
                                        provider: {
                                            label: 'label.ha.provider',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                $.ajax({
                                                    url: createURL('listHostHAProviders'),
                                                    data: {'hypervisor': args.context.hosts[0].hypervisor},
                                                    dataType: 'json',
                                                    success: function (json) {
                                                        var response = json.listhosthaprovidersresponse;
                                                        var items = [];
                                                        items.push({
                                                            id: '',
                                                            description: _l('')
                                                        });
                                                        if (response.haprovider) {
                                                            $.each(response.haprovider, function (idx, item) {
                                                                items.push({
                                                                    id: item.haprovider,
                                                                    description: item.haprovider
                                                                });
                                                            });
                                                        }
                                                        args.response.success({
                                                            data: items
                                                        });
                                                    },
                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(json));
                                                    }
                                                });
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = args.data;
                                    data.hostid = args.context.hosts[0].id;
                                    $.ajax({
                                        url: createURL('configureHAForHost'),
                                        data: data,
                                        dataType: 'json',
                                        success: function (json) {
                                            var jid = json.configurehaforhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            enableHA: {
                                label: 'label.ha.enable',
                                action: function (args) {
                                    var data = {
                                        hostid: args.context.hosts[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("enableHAForHost"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.enablehaforhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }

                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'label.ha.enable';
                                    },
                                    notification: function (args) {
                                        return 'label.ha.enable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            disableHA: {
                                label: 'label.ha.disable',
                                action: function (args) {
                                    var data = {
                                        hostid: args.context.hosts[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("disableHAForHost"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.disablehaforhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }

                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'label.ha.disable';
                                    },
                                    notification: function (args) {
                                        return 'label.ha.disable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            blankOutOfBandManagement: {
                                label: '',
                                action: function (args) {
                                }
                            },

                            configureOutOfBandManagement: {
                                label: 'label.outofbandmanagement.configure',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.configure';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.configure';
                                    }
                                },
                                createForm: {
                                    title: 'label.outofbandmanagement.configure',
                                    fields: {
                                        address: {
                                            label: 'label.outofbandmanagement.address',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        port: {
                                            label: 'label.outofbandmanagement.port',
                                            validation: {
                                                required: true
                                            }
                                        },
                                        username: {
                                            label: 'label.outofbandmanagement.username',
                                            validation: {
                                                required: false
                                            }
                                        },
                                        password: {
                                            label: 'label.outofbandmanagement.password',
                                            isPassword: true,
                                            validation: {
                                                required: false
                                            },
                                        },
                                        driver: {
                                            label: 'label.outofbandmanagement.driver',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                var oobm = args.context.hosts[0].outofbandmanagement;
                                                if (oobm) {
                                                    args.$form.find('input[name=address]').val(oobm.address);
                                                    args.$form.find('input[name=port]').val(oobm.port);
                                                    args.$form.find('input[name=username]').val(oobm.username);

                                                    args.$form.find('input[name=address]').change(function() {
                                                        $this.find('input[name=address]').val(oobm.address);
                                                    });
                                                }

                                                var items = [];
                                                items.push({
                                                    id: 'ipmitool',
                                                    description: 'ipmitool - ipmitool based shell driver'
                                                });
                                                items.push({
                                                    id: 'nestedcloudstack',
                                                    description: 'nested-cloudstack - controls host that is a VM in a parent cloudstack (testing purposes only)'
                                                });
                                                items.push({
                                                    id: 'redfish',
                                                    description: 'redfish - controls host using a redfish java client'
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        }
                                    }
                                },
                                action: function (args) {
                                    var data = args.data;
                                    data.hostid = args.context.hosts[0].id;

                                    $.ajax({
                                        url: createURL('configureOutOfBandManagement'),
                                        data: data,
                                        dataType: 'json',
                                        success: function (json) {
                                            var response = json.configureoutofbandmanagementresponse;
                                            args.response.success({
                                                actionFilter: hostActionfilter,
                                                data: response
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            },

                            enableOutOfBandManagement: {
                                label: 'label.outofbandmanagement.enable',
                                action: function (args) {
                                    var data = {
                                        hostid: args.context.hosts[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("enableOutOfBandManagementForHost"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.enableoutofbandmanagementforhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }

                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.enable';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.enable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            disableOutOfBandManagement: {
                                label: 'label.outofbandmanagement.disable',
                                action: function (args) {
                                    var data = {
                                        hostid: args.context.hosts[0].id,
                                    };
                                    $.ajax({
                                        url: createURL("disableOutOfBandManagementForHost"),
                                        data: data,
                                        success: function (json) {
                                            var jid = json.disableoutofbandmanagementforhostresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }

                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.disable';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.disable';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            issueOutOfBandManagementPowerAction: {
                                label: 'label.outofbandmanagement.action.issue',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.issue';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.issue';
                                    }
                                },
                                createForm: {
                                    title: 'label.outofbandmanagement.action.issue',
                                    desc: function(args) {
                                          var host = args.context.hosts[0];
                                          if (host.resourcestate == 'Maintenance' || host.resourcestate == 'PrepareForMaintenance' ||
                                                host.resourcestate == 'ErrorInPrepareForMaintenance' || host.resourcestate == 'ErrorInMaintenance') {
                                              return _l('message.outofbandmanagement.action.maintenance');
                                          }
                                    },
                                    fields: {
                                        action: {
                                            label: 'label.outofbandmanagement.action',
                                            validation: {
                                                required: true
                                            },
                                            select: function (args) {
                                                var items = [];
                                                items.push({
                                                    id: 'ON',
                                                    description: 'ON - turn on host'
                                                });
                                                items.push({
                                                    id: 'OFF',
                                                    description: 'OFF - turn off host'
                                                });
                                                items.push({
                                                    id: 'CYCLE',
                                                    description: 'CYCLE - power cycle the host'
                                                });
                                                items.push({
                                                    id: 'RESET',
                                                    description: 'RESET - power reset the host'
                                                });
                                                items.push({
                                                    id: 'SOFT',
                                                    description: 'SOFT - soft shutdown the host using ACPI etc'
                                                });
                                                items.push({
                                                    id: 'STATUS',
                                                    description: 'STATUS - update power status of the host'
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            }
                                        },
                                    }
                                },
                                action: function (args) {
                                    var data = args.data;
                                    data.hostid = args.context.hosts[0].id;
                                    $.ajax({
                                        url: createURL('issueOutOfBandManagementPowerAction'),
                                        data: data,
                                        dataType: 'json',
                                        success: function (json) {
                                            var jid = json.issueoutofbandmanagementpoweractionresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            changeOutOfBandManagementPassword: {
                                label: 'label.outofbandmanagement.changepassword',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.outofbandmanagement.changepassword';
                                    },
                                    notification: function (args) {
                                        return 'message.outofbandmanagement.changepassword';
                                    }
                                },
                                createForm: {
                                    title: 'label.outofbandmanagement.changepassword',
                                    fields: {
                                        password: {
                                            label: 'label.outofbandmanagement.password',
                                            isPassword: true,
                                            validation: {
                                                required: false
                                            },
                                        },
                                        reenterpassword: {
                                            label: 'label.outofbandmanagement.reenterpassword',
                                            isPassword: true,
                                            validation: {
                                                required: false
                                            }
                                        },
                                    }
                                },
                                action: function (args) {
                                    var data = args.data;
                                    if (data.password != data.reenterpassword) {
                                        args.response.error("Passwords do not match");
                                        return;
                                    }
                                    data.hostid = args.context.hosts[0].id;
                                    $.ajax({
                                        url: createURL('changeOutOfBandManagementPassword'),
                                        data: data,
                                        dataType: 'json',
                                        success: function (json) {
                                            var jid = json.changeoutofbandmanagementpasswordresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getActionFilter: function () {
                                                        return hostActionfilter;
                                                    }
                                                }
                                            });
                                        },
                                        error: function (json) {
                                            args.response.error(parseXMLHttpResponse(json));
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            }

                        },
                        tabFilter: function (args) {
                            var hiddenTabs =[];
                            var host = args.context.hosts[0];
                            if (host.gpugroup == null) {
                                hiddenTabs.push("gpu");
                            }
                            if (host.outofbandmanagement == null || !host.outofbandmanagement.enabled) {
                                hiddenTabs.push("outofbandmanagement");
                            }
                            if (host.hostha == null || (host.hypervisor != 'KVM' && host.hypervisor != 'Simulator')) {
                                hiddenTabs.push("ha");
                            }
                            return hiddenTabs;
                        },
                        tabs: {
                            details: {
                                title: 'label.details',

                                preFilter: function (args) {
                                    var hiddenFields =[];
                                    $.ajax({
                                        url: createURL('listConfigurations&name=ha.tag'),
                                        dataType: 'json',
                                        async: false,
                                        success: function (json) {
                                            if (json.listconfigurationsresponse.configuration == null || json.listconfigurationsresponse.configuration[0].value == null || json.listconfigurationsresponse.configuration[0].value.length == 0) {
                                                hiddenFields.push('hahost');
                                            }
                                        }
                                    });
                                    return hiddenFields;
                                },

                                fields:[ {
                                    name: {
                                        label: 'label.name',
                                        isEditable: true
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    resourcestate: {
                                        label: 'label.resource.state'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    powerstate: {
                                        label: 'label.powerstate'
                                    },
                                    type: {
                                        label: 'label.type'
                                    },
                                    hypervisor: {
                                        label: 'label.hypervisor'
                                    },
                                    hypervisorversion: {
                                        label: 'label.hypervisor.version'
                                    },
                                    hastate: {
                                        label: 'label.ha.state'
                                    },
                                    haprovider: {
                                        label: 'label.ha.provider'
                                    },
                                    hosttags: {
                                        label: 'label.host.tags',
                                        isEditable: true,
                                        isTokenInput: true,
                                        dataProvider: function(args) {
                                            $.ajax({
                                                url: createURL("listHostTags"),
                                                dataType: "json",
                                                success: function(json) {
                                                    var item = json.listhosttagsresponse.hosttag;
                                                    var tags = [];

                                                    if (item != null)
                                                    {
                                                        tags = $.map(item, function(tag) {
                                                            return {
                                                                       id: tag.name,
                                                                       name: tag.name
                                                                   };
                                                        });
                                                    }

                                                    args.response.success({
                                                        data: tags,
                                                        hintText: _l('hint.type.part.host.tag'),
                                                        noResultsText: _l('hint.no.host.tags')
                                                    });
                                                },
                                                error: function(XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        }
                                    },
                                    ueficapability: {
                                        label:'label.host.ueficapability',
                                        converter: cloudStack.converters.toBooleanText
                                    },
                                    hahost: {
                                        label: 'label.ha.enabled',
                                        converter: cloudStack.converters.toBooleanText
                                    },
                                    oscategoryid: {
                                        label: 'label.os.preference',
                                        isEditable: true,
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listOsCategories"),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var oscategoryObjs = json.listoscategoriesresponse.oscategory;
                                                    var items =[ {
                                                        id: '',
                                                        description: _l('')
                                                    }];
                                                    $(oscategoryObjs).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    zonename: {
                                        label: 'label.zone'
                                    },
                                    podname: {
                                        label: 'label.pod'
                                    },
                                    clustername: {
                                        label: 'label.cluster'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    annotation: {
                                        label: 'label.annotation',
                                        isEditable: true
                                    },
                                    lastannotated: {
                                        label: 'label.last.annotated',
                                        converter: cloudStack.converters.toLocalDate
                                    },
                                    username: {
                                        label: 'label.annotated.by'
                                    },
                                    disconnected: {
                                        label: 'label.last.disconnected'
                                    },
                                    cpusockets: {
                                        label: 'label.number.of.cpu.sockets'
                                    },
                                    managementServers: {
                                        label: 'label.number.of.management.servers'
                                    }
                                }, {

                                    isdedicated: {
                                        label: 'label.dedicated'
                                    },
                                    domainid: {
                                        label: 'label.domain.id'
                                    }
                                }],

                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listHosts&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.listhostsresponse.host[0];
                                            if (item && item.outofbandmanagement) {
                                                item.powerstate = item.outofbandmanagement.powerstate;
                                            }

                                            if (!item.hypervisorversion && item.details && item.details["Host.OS"]) {
                                                item.hypervisorversion =  item.details["Host.OS"] + " " +  item.details["Host.OS.Version"];
                                            }

                                            if (item && item.hostha) {
                                                item.hastate = item.hostha.hastate;
                                                item.haprovider = item.hostha.haprovider;
                                                item.haenabled = item.hostha.haenable;
                                            }

                                            item.annotation = item.annotation;
                                            item.lastannotated = item.lastannotated;
                                            item.username = item.username;

                                            $.ajax({
                                                url: createURL("listDedicatedHosts&hostid=" + args.context.hosts[0].id),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    if (json.listdedicatedhostsresponse.dedicatedhost != undefined) {
                                                        var hostItem = json.listdedicatedhostsresponse.dedicatedhost[0];
                                                        if (hostItem.domainid != null) {
                                                            $.extend(item, {
                                                                isdedicated: _l('label.yes'),
                                                                domainid: hostItem.domainid
                                                            });
                                                        }
                                                    } else
                                                    $.extend(item, {
                                                        isdedicated: _l('label.no')
                                                    })
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                                }
                                            });
                                            args.response.success({
                                                actionFilter: hostActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                }
                            },

                            ha: {
                                title: 'label.ha',
                                fields: {
                                    haenable: {
                                        label: 'label.ha.enabled',
                                        converter: cloudStack.converters.toBooleanText
                                    },
                                    hastate: {
                                        label: 'label.ha.state'
                                    },
                                    haprovider: {
                                        label: 'label.ha.provider'
                                    },
                                },
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listHosts&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var host = json.listhostsresponse.host[0];
                                            var hostha = {};
                                            if (host && host.hostha) {
                                                hostha = host.hostha;
                                            }
                                            args.response.success({
                                                data: hostha
                                            });
                                        }
                                    });
                                }
                            },

                            outofbandmanagement: {
                                title: 'label.outofbandmanagement',
                                fields: {
                                    powerstate: {
                                        label: 'label.powerstate'
                                    },
                                    driver: {
                                        label: 'label.outofbandmanagement.driver'
                                    },
                                    username: {
                                        label: 'label.outofbandmanagement.username'
                                    },
                                    address: {
                                        label: 'label.outofbandmanagement.address'
                                    },
                                    port: {
                                        label: 'label.outofbandmanagement.port'
                                    }
                                },
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listHosts&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var host = json.listhostsresponse.host[0];
                                            var oobm = {};
                                            if (host && host.outofbandmanagement) {
                                                oobm = host.outofbandmanagement;
                                            }
                                            args.response.success({
                                                data: oobm
                                            });
                                        }
                                    });
                                }
                            },

                            stats: {
                                title: 'label.statistics',
                                fields: {
                                    totalCPU: {
                                        label: 'label.total.cpu'
                                    },
                                    cpuused: {
                                        label: 'label.cpu.utilized'
                                    },
                                    cpuallocated: {
                                        label: 'label.cpu.allocated.for.VMs'
                                    },
                                    memorytotal: {
                                        label: 'label.memory.total'
                                    },
                                    memoryallocated: {
                                        label: 'label.memory.allocated'
                                    },
                                    memoryused: {
                                        label: 'label.memory.used'
                                    },
                                    networkkbsread: {
                                        label: 'label.network.read'
                                    },
                                    networkkbswrite: {
                                        label: 'label.network.write'
                                    }
                                },
                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listHosts&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jsonObj = json.listhostsresponse.host[0];
                                            args.response.success({
                                                data: {
                                                    totalCPU: jsonObj.cpunumber + " x " + cloudStack.converters.convertHz(jsonObj.cpuspeed),
                                                    cpuused: jsonObj.cpuused,
                                                    cpuallocated: (jsonObj.cpuallocated == null || jsonObj.cpuallocated == 0) ? "N/A": jsonObj.cpuallocated,
                                                    memorytotal: (jsonObj.memorytotal == null || jsonObj.memorytotal == 0) ? "N/A": cloudStack.converters.convertBytes(jsonObj.memorytotal),
                                                    memoryallocated: (jsonObj.memoryallocated == null || jsonObj.memoryallocated == 0) ? "N/A": cloudStack.converters.convertBytes(jsonObj.memoryallocated),
                                                    memoryused: (jsonObj.memoryused == null || jsonObj.memoryused == 0) ? "N/A": cloudStack.converters.convertBytes(jsonObj.memoryused),
                                                    networkkbsread: (jsonObj.networkkbsread == null) ? "N/A": cloudStack.converters.convertBytes(jsonObj.networkkbsread * 1024),
                                                    networkkbswrite: (jsonObj.networkkbswrite == null) ? "N/A": cloudStack.converters.convertBytes(jsonObj.networkkbswrite * 1024)
                                                }
                                            });
                                        }
                                    });
                                }
                            },
                            gpu: {
                                title: 'label.gpu',
                                custom: function (args) {
                                    var gpugroups = null;
                                    $.ajax({
                                        url: createURL("listHosts&id=" + args.context.hosts[0].id),
                                        dataType: "json",
                                        async: false,
                                        success: function (json) {
                                            var item = json.listhostsresponse.host[0];
                                            if (item != null && item.gpugroup != null)
                                                gpugroups = item.gpugroup;
                                        }
                                    });

                                    var $tabcontent = $('<div>').addClass('gpugroups');

                                    $(gpugroups).each(function() {
                                        var gpugroupObj = this;

                                        var $groupcontainer = $('<div>').addClass('gpugroup-container');

                                        //group name
                                        $groupcontainer.append($('<div>').addClass('title')
                                                            .append($('<span>').html(gpugroupObj.gpugroupname)));
                                        //vgpu details
                                        var $groupdetails = $('<div>').listView({
                                            context: args.context,
                                            listView: {
                                                id: 'gputypes',
                                                hideToolbar: true,
                                                fields: {
                                                    vgputype: {
                                                        label: 'label.vgpu.type'
                                                    },
                                                    maxvgpuperpgpu: {
                                                        label: 'label.vgpu.max.vgpu.per.gpu',
                                                        converter: function (args) {
                                                            return (args == null || args == 0) ? "" : args;
                                                        }
                                                    },
                                                    videoram: {
                                                        label: 'label.vgpu.video.ram',
                                                        converter: function (args) {
                                                            return (args == null || args == 0) ? "" : cloudStack.converters.convertBytes(args);
                                                        }
                                                    },
                                                    maxresolution: {
                                                        label: 'label.vgpu.max.resolution'
                                                    },
                                                    remainingcapacity: {
                                                        label: 'label.vgpu.remaining.capacity'
                                                    }
                                                },
                                                dataProvider: function (args) {
                                                    var items;

                                                    if(typeof(gpugroupObj.vgpu) != "undefined") {
                                                        items = gpugroupObj.vgpu.sort(function(a, b) {
                                                            return a.maxvgpuperpgpu >= b.maxvgpuperpgpu;
                                                        });
                                                    }
                                                    else {
                                                        items = gpugroupObj.vgpu;
                                                    }
                                                    $(items).each(function () {
                                                        this.maxresolution = (this.maxresolutionx == null || this.maxresolutionx == 0
                                                                || this.maxresolutiony == null || this.maxresolutiony == 0)
                                                                ? "" : this.maxresolutionx + " x " + this.maxresolutiony;
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            }
                                        });
                                        $groupcontainer.append($groupdetails);
                                        $tabcontent.append($groupcontainer);
                                    });
                                    return $tabcontent;
                                }
                            }
                        }
                    }
                }
            },
            'primary-storage': {
                title: 'label.primary.storage',
                id: 'primarystorages',
                listView: {
                    id: 'primarystorages',
                    section: 'primary-storage',
                    fields: {
                        name: {
                            label: 'label.name',
                            truncate: true
                        },
                        ipaddress: {
                            label: 'label.server'
                        },
                        path: {
                            label: 'label.path',
                            truncate: true
                        },
                        type: {
                            label: 'label.type'
                        },
                        scope: {
                            label: 'label.scope'
                        },
                        clustername: {
                            label: 'label.cluster',
                            truncate: true
                        },
                        zonename: {
                            label: 'label.zone'
                        },
                        state: {
                            label: 'label.state',
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            indicator: {
                                'Up': 'on',
                                'Down': 'off',
                                'Removed': 'off',
                                'ErrorInMaintenance': 'off',
                                'ErrorInPrepareForMaintenance': 'warning',
                                'PrepareForMaintenance': 'warning',
                                'CancelMaintenance': 'warning',
                                'Maintenance': 'warning',
                            }
                        }
                    },

                    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;
                                }
                            }
                        }
                        array1.push("&zoneid=" + args.context.zones[0].id);
                        if ("pods" in args.context)
                        array1.push("&podid=" + args.context.pods[0].id);
                        if ("clusters" in args.context)
                        array1.push("&clusterid=" + args.context.clusters[0].id);
                        $.ajax({
                            url: createURL("listStoragePools&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.liststoragepoolsresponse.storagepool;
                                args.response.success({
                                    actionFilter: primarystorageActionfilter,
                                    data: items
                                });
                            }
                        });
                    },

                    actions: {
                        add: {
                            label: 'label.add.primary.storage',

                            createForm: {
                                title: 'label.add.primary.storage',
                                fields: {
                                    scope: {
                                        label: 'label.scope',
                                        select: function (args) {
                                            var scope =[ {
                                                id: 'cluster',
                                                description: _l('label.cluster')
                                            },
                                            {
                                                id: 'zone',
                                                description: _l('label.zone.wide')
                                            }
                                            // { id: 'host', description: _l('label.host') }
                                            ];

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

                                            args.$select.change(function () {
                                                var $form = $(this).closest('form');
                                                var scope = $(this).val();

                                                if (scope == 'zone') {
                                                    $form.find('.form-item[rel=podId]').hide();
                                                    $form.find('.form-item[rel=clusterId]').hide();
                                                    $form.find('.form-item[rel=hostId]').hide();
                                                    $form.find('.form-item[rel=hypervisor]').css('display', 'inline-block');
                                                } else if (scope == 'cluster') {

                                                    $form.find('.form-item[rel=hostId]').hide();
                                                    $form.find('.form-item[rel=podId]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=clusterId]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=hypervisor]').hide();
                                                } else if (scope == 'host') {
                                                    $form.find('.form-item[rel=podId]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=clusterId]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=hostId]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=hypervisor]').hide();
                                                }
                                            })
                                        }
                                    },


                                    hypervisor: {
                                        label: 'label.hypervisor',
                                        isHidden: true,
                                        select: function (args) {
                                            var items =[];
                                            items.push({
                                                id: 'KVM',
                                                description: _l('KVM')
                                            });
                                            items.push({
                                                id: 'VMware',
                                                description: _l('VMware')
                                            });
                                            items.push({
                                                id: 'Hyperv',
                                                description: _l('Hyperv')
                                            });
                                            items.push({
                                                id: 'Any',
                                                description: _l('Any')
                                            });
                                            args.response.success({
                                                data: items
                                            });
                                        }
                                    },

                                    zoneid: {
                                        label: 'label.zone',
                                        docID: 'helpPrimaryStorageZone',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            var data = args.context.zones ? {
                                                id: args.context.zones[0].id
                                            }: {};

                                            $.ajax({
                                                url: createURL('listZones'),
                                                data: data,
                                                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
                                                            };
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },
                                    podId: {
                                        label: 'label.pod',
                                        dependsOn: 'zoneid',
                                        docID: 'helpPrimaryStoragePod',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listPods&zoneid=" + args.zoneid),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var pods = json.listpodsresponse.pod;
                                                    var items =[];
                                                    $(pods).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    clusterId: {
                                        label: 'label.cluster',
                                        docID: 'helpPrimaryStorageCluster',
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'podId',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL("listClusters&podid=" + args.podId),
                                                dataType: "json",
                                                async: false,
                                                success: function (json) {
                                                    clusterObjs = json.listclustersresponse.cluster;
                                                    var items =[];
                                                    $(clusterObjs).each(function () {
                                                        items.push({
                                                            id: this.id,
                                                            description: this.name
                                                        });
                                                    });
                                                    args.response.success({
                                                        actionFilter: clusterActionfilter,
                                                        data: items
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    hostId: {
                                        label: 'label.host',
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'clusterId',
                                        select: function (args) {
                                            $.ajax({
                                                url: createURL('listHosts'),
                                                data: {
                                                    clusterid: args.clusterId
                                                },
                                                success: function (json) {
                                                    var hosts = json.listhostsresponse.host ?
                                                    json.listhostsresponse.host:[]
                                                    args.response.success({
                                                        data: $.map(hosts, function (host) {
                                                            return {
                                                                id: host.id,
                                                                description: host.name
                                                            }
                                                        })
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    name: {
                                        label: 'label.name',
                                        docID: 'helpPrimaryStorageName',
                                        validation: {
                                            required: true
                                        }
                                    },

                                    protocol: {
                                        label: 'label.protocol',
                                        docID: 'helpPrimaryStorageProtocol',
                                        validation: {
                                            required: true
                                        },
                                        dependsOn: 'clusterId',
                                        select: function (args) {
                                            var clusterId = args.clusterId;
                                            if (clusterId == null || clusterId.length == 0) {
                                                args.response.success({
                                                    data: []
                                                });
                                            return;
                                            }

                                            $(clusterObjs).each(function () {
                                                if (this.id == clusterId) {
                                                    selectedClusterObj = this;
                                                    return false; //break the $.each() loop
                                                }
                                            });

                                            if (selectedClusterObj.hypervisortype == "KVM") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                                items.push({
                                                    id: "SharedMountPoint",
                                                    description: "SharedMountPoint"
                                                });
                                                items.push({
                                                    id: "rbd",
                                                    description: "RBD"
                                                });
                                                items.push({
                                                    id: "clvm",
                                                    description: "CLVM"
                                                });
                                                items.push({
                                                    id: "gluster",
                                                    description: "Gluster"
                                                });
                                                items.push({
                                                    id: "custom",
                                                    description: "custom"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            } else if (selectedClusterObj.hypervisortype == "XenServer") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                                items.push({
                                                    id: "PreSetup",
                                                    description: "PreSetup"
                                                });
                                                items.push({
                                                    id: "iscsi",
                                                    description: "iscsi"
                                                });
                                                items.push({
                                                    id: "custom",
                                                    description: "custom"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            } else if (selectedClusterObj.hypervisortype == "VMware") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                                items.push({
                                                    id: "vmfs",
                                                    description: "vmfs"
                                                });
                                                items.push({
                                                    id: "custom",
                                                    description: "custom"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            } else if (selectedClusterObj.hypervisortype == "Hyperv") {
                                                var items =[];
                                                items.push({
                                                    id: "SMB",
                                                    description: "SMB/CIFS"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            } else if (selectedClusterObj.hypervisortype == "Ovm") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                                items.push({
                                                    id: "ocfs2",
                                                    description: "ocfs2"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            } else if (selectedClusterObj.hypervisortype == "LXC") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                                items.push({
                                                    id: "SharedMountPoint",
                                                    description: "SharedMountPoint"
                                                });
                                                items.push({
                                                    id: "rbd",
                                                    description: "RBD"
                                                });
                                                args.response.success({
                                                    data: items
                                                });
                                            // 3.3.2 has ceph/ocfs2/iscsi etc
                                            } else if (selectedClusterObj.hypervisortype == "Ovm3") {
                                                var items =[];
                                                items.push({
                                                    id: "nfs",
                                                    description: "nfs"
                                                });
                                            } else {
                                                args.response.success({
                                                    data:[]
                                                });
                                            }

                                            args.$select.change(function () {
                                                var $form = $(this).closest('form');

                                                var protocol = $(this).val();
                                                if (protocol == null)
                                                return;


                                                if (protocol == "nfs") {
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

                                                    $form.find('.form-item[rel=path]').css('display', 'inline-block');
                                                    var $required = $form.find('.form-item[rel=path]').find(".name").find("label span");
                                                    $form.find('.form-item[rel=path]').find(".name").find("label").text("Path:").prepend($required);

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "SMB") {
                                                    //"SMB" show almost the same fields as "nfs" does, except 3 more SMB-specific fields.
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

                                                    $form.find('.form-item[rel=path]').css('display', 'inline-block');
                                                    var $required = $form.find('.form-item[rel=path]').find(".name").find("label span");
                                                    $form.find('.form-item[rel=path]').find(".name").find("label").text("Path:").prepend($required);

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

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "ocfs2") {
                                                    //ocfs2 is the same as nfs, except no server field.
                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

                                                    $form.find('.form-item[rel=path]').css('display', 'inline-block');
                                                    var $required = $form.find('.form-item[rel=path]').find(".name").find("label span");
                                                    $form.find('.form-item[rel=path]').find(".name").find("label").text("Path:").prepend($required);

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "PreSetup") {
                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("localhost");

                                                    $form.find('.form-item[rel=path]').css('display', 'inline-block');
                                                    var $required = $form.find('.form-item[rel=path]').find(".name").find("label span");
                                                    $form.find('.form-item[rel=path]').find(".name").find("label").text("SR Name-Label:").prepend($required);

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "custom") {
                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("localhost");

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

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "iscsi") {
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

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

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if ($(this).val() == "clvm") {
                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("localhost");

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

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "vmfs") {
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

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

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "SharedMountPoint") {
                                                    //"SharedMountPoint" show the same fields as "nfs" does.
                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("localhost");

                                                    $form.find('.form-item[rel=path]').css('display', 'inline-block');
                                                    var $required = $form.find('.form-item[rel=path]').find(".name").find("label span");
                                                    $form.find('.form-item[rel=path]').find(".name").find("label").text("Path:").prepend($required);

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "rbd") {
                                                    $form.find('.form-item[rel=rbdmonitor]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=rbdmonitor]').find(".name").find("label").text("RADOS Monitor:");

                                                    $form.find('.form-item[rel=rbdpool]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=rbdpool]').find(".name").find("label").text("RADOS Pool:");

                                                    $form.find('.form-item[rel=rbdid]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=rbdid]').find(".name").find("label").text("RADOS User:");

                                                    $form.find('.form-item[rel=rbdsecret]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=rbdsecret]').find(".name").find("label").text("RADOS Secret:");

                                                    $form.find('.form-item[rel=server]').hide();
                                                    $form.find('.form-item[rel=iqn]').hide();
                                                    $form.find('.form-item[rel=lun]').hide();
                                                    $form.find('.form-item[rel=volumegroup]').hide();
                                                    $form.find('.form-item[rel=path]').hide();
                                                    $form.find('.form-item[rel=vCenterDataCenter]').hide();
                                                    $form.find('.form-item[rel=vCenterDataStore]').hide();

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

                                                    $form.find('.form-item[rel=glustervolume]').hide();
                                                } else if (protocol == "gluster") {
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input");

                                                    $form.find('.form-item[rel=glustervolume]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=glustervolume]').find(".name").find("label").text("Volume:");

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

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();
                                                } else {
                                                    $form.find('.form-item[rel=server]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=server]').find(".value").find("input").val("");

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

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

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

                                                    $form.find('.form-item[rel=rbdmonitor]').hide();
                                                    $form.find('.form-item[rel=rbdpool]').hide();
                                                    $form.find('.form-item[rel=rbdid]').hide();
                                                    $form.find('.form-item[rel=rbdsecret]').hide();

                                                    $form.find('.form-item[rel=smbUsername]').hide();
                                                    $form.find('.form-item[rel=smbPassword]').hide();
                                                    $form.find('.form-item[rel=smbDomain]').hide();

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

                                            args.$select.trigger("change");
                                        }
                                    },
                                    //always appear (end)

                                    server: {
                                        label: 'label.server',
                                        docID: 'helpPrimaryStorageServer',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    //nfs
                                    path: {
                                        label: 'label.path',
                                        docID: 'helpPrimaryStoragePath',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    provider: {
                                        label: 'label.provider',
                                        validation: {
                                            required: true
                                        },
                                        select: function (args) {
                                            var data = args.context.providers ?
                                                { id: args.context.providers[0].id } :
                                                {};

                                            $.ajax({
                                                url: createURL('listStorageProviders'),
                                                data: {
                                                    type: 'primary'
                                                },
                                                success: function (json) {
                                                    var providers = json.liststorageprovidersresponse.dataStoreProvider ? json.liststorageprovidersresponse.dataStoreProvider : [];

                                                    args.response.success({
                                                        data: $.map(providers, function (provider) {
                                                            return {
                                                                id: provider.name,
                                                                description: provider.name
                                                            };
                                                        })
                                                    });
                                                }
                                            });
                                            args.$select.change(function () {
                                                var $form = $(this).closest('form');
                                                var scope = $(this).val();

                                                if (scope == 'DefaultPrimary') {
                                                    $form.find('.form-item[rel=isManaged]').hide();
                                                    $form.find('.form-item[rel=capacityIops]').hide();
                                                    $form.find('.form-item[rel=capacityBytes]').hide();
                                                    $form.find('.form-item[rel=url]').hide();
                                                } else {
                                                    $form.find('.form-item[rel=isManaged]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=capacityIops]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=capacityBytes]').css('display', 'inline-block');
                                                    $form.find('.form-item[rel=url]').css('display', 'inline-block');
                                                }
                                            }
                                        )
                                    }},
                                    isManaged: {
                                        label: 'label.managed',
                                        docID: 'helpManaged',
                                        isBoolean: true,
                                        isChecked: false,
                                        validation: {
                                            required: false
                                        }
                                    },
                                    capacityBytes: {
                                        label: 'label.capacity.bytes',
                                        docID: 'helpCapacityBytes',
                                        validation: {
                                            required: false
                                        }
                                    },
                                    capacityIops: {
                                        label: 'label.capacity.iops',
                                        docID: 'helpCapacityIops',
                                        validation: {
                                            required: false
                                        }
                                    },
                                    url: {
                                        label: 'label.url',
                                        docID: 'helpUrl',
                                        validation: {
                                            required: false
                                        }
                                    },
                                    //SMB
                                    smbUsername: {
                                        label: 'label.smb.username',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    smbPassword: {
                                        label: 'label.smb.password',
                                        isPassword: true,
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    smbDomain: {
                                        label: 'label.smb.domain',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    //iscsi
                                    iqn: {
                                        label: 'label.target.iqn',
                                        docID: 'helpPrimaryStorageTargetIQN',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    lun: {
                                        label: 'label.LUN.number',
                                        docID: 'helpPrimaryStorageLun',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    //clvm
                                    volumegroup: {
                                        label: 'label.volgroup',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    //vmfs
                                    vCenterDataCenter: {
                                        label: 'label.vcenter.datacenter',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    vCenterDataStore: {
                                        label: 'label.vcenter.datastore',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    // RBD
                                    rbdmonitor: {
                                        label: 'label.rbd.monitor',
                                        docID: 'helpPrimaryStorageRBDMonitor',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    rbdpool: {
                                        label: 'label.rbd.pool',
                                        docID: 'helpPrimaryStorageRBDPool',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },
                                    rbdid: {
                                        label: 'label.rbd.id',
                                        docID: 'helpPrimaryStorageRBDId',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },
                                    rbdsecret: {
                                        label: 'label.rbd.secret',
                                        docID: 'helpPrimaryStorageRBDSecret',
                                        validation: {
                                            required: false
                                        },
                                        isHidden: true
                                    },

                                    //gluster
                                    glustervolume: {
                                        label: 'label.gluster.volume',
                                        validation: {
                                            required: true
                                        },
                                        isHidden: true
                                    },

                                    //always appear (begin)
                                    storageTags: {
                                        label: 'label.storage.tags',
                                        docID: 'helpPrimaryStorageTags',
                                        isTokenInput: true,
                                        validation: {
                                            required: false
                                        },
                                        dataProvider: function(args) {
                                            $.ajax({
                                                url: createURL("listStorageTags"),
                                                dataType: "json",
                                                success: function(json) {
                                                    var item = json.liststoragetagsresponse.storagetag;
                                                    var tags = [];

                                                    if (item != null)
                                                    {
                                                        tags = $.map(item, function(tag) {
                                                            return {
                                                                       id: tag.name,
                                                                       name: tag.name
                                                                   };
                                                        });
                                                    }

                                                    args.response.success({
                                                        data: tags,
                                                        hintText: _l('hint.type.part.storage.tag'),
                                                        noResultsText: _l('hint.no.storage.tags')
                                                    });
                                                },
                                                error: function(XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        }
                                    }
                                    //always appear (end)
                                }
                            },

                            /******************************/
                            action: function (args) {
                                var array1 =[];
                                array1.push("&scope=" + encodeURIComponent(args.data.scope));

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

                                if (args.data.scope == 'zone') {

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

                                if (args.data.scope == 'cluster') {

                                    array1.push("&podid=" + args.data.podId);
                                    array1.push("&clusterid=" + args.data.clusterId);
                                }

                                if (args.data.scope == 'host') {
                                    array1.push("&podid=" + args.data.podId);
                                    array1.push("&clusterid=" + args.data.clusterId);
                                    array1.push("&hostid=" + args.data.hostId);
                                }

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

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

                                if (args.data.provider == "DefaultPrimary")
                                {
                                    var server = args.data.server;
                                    var url = null;
                                    if (args.data.protocol == "nfs") {
                                        var path = args.data.path;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        url = nfsURL(server, path);
                                    } else if (args.data.protocol == "SMB") {
                                        var path = args.data.path;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        url = smbURL(server, path);
                                        array1.push("&details[0].user=" + args.data.smbUsername);
                                        array1.push("&details[1].password=" + encodeURIComponent(args.data.smbPassword));
                                        array1.push("&details[2].domain=" + args.data.smbDomain);
                                    } else if (args.data.protocol == "PreSetup") {
                                        var path = args.data.path;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        url = presetupURL(server, path);
                                    } else if (args.data.protocol == "ocfs2") {
                                        var path = args.data.path;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        url = ocfs2URL(server, path);
                                    } else if (args.data.protocol == "SharedMountPoint") {
                                        var path = args.data.path;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        url = SharedMountPointURL(server, path);
                                    } else if (args.data.protocol == "clvm") {
                                        var vg = args.data.volumegroup;
                                        if (vg.substring(0, 1) != "/")
                                            vg = "/" + vg;
                                        url = clvmURL(vg);
                                    } else if (args.data.protocol == "rbd") {
                                        var rbdmonitor = args.data.rbdmonitor;
                                        var rbdpool = args.data.rbdpool;
                                        var rbdid = args.data.rbdid;
                                        var rbdsecret = args.data.rbdsecret;
                                        url = rbdURL(rbdmonitor, rbdpool, rbdid, rbdsecret);
                                    } else if (args.data.protocol == "vmfs") {
                                        var path = args.data.vCenterDataCenter;
                                        if (path.substring(0, 1) != "/")
                                            path = "/" + path;
                                        path += "/" + args.data.vCenterDataStore;
                                        url = vmfsURL("dummy", path);
                                    } else if (args.data.protocol == "gluster") {
                                        var glustervolume = args.data.glustervolume;

                                        if (glustervolume.substring(0, 1) != "/")
                                            glustervolume = "/" + glustervolume;
                                        url = glusterURL(server, glustervolume);
                                    } else if (args.data.protocol == "iscsi") {
                                        var iqn = args.data.iqn;
                                        if (iqn.substring(0, 1) != "/")
                                            iqn = "/" + iqn;
                                        var lun = args.data.lun;
                                        url = iscsiURL(server, iqn, lun);
                                    } else {
                                        url = "";
                                    }

                                    array1.push("&url=" + encodeURIComponent(url));
                                }
                                else
                                {
                                    array1.push("&managed=" + (args.data.isManaged == "on").toString());

                                    if (args.data.capacityBytes != null && args.data.capacityBytes.length > 0)
                                    {
                                        array1.push("&capacityBytes=" + args.data.capacityBytes.split(",").join(""));
                                    }

                                    if (args.data.capacityIops != null && args.data.capacityIops.length > 0)
                                    {
                                        array1.push("&capacityIops=" + args.data.capacityIops.split(",").join(""));
                                    }

                                    if (args.data.url != null && args.data.url.length > 0)
                                    {
                                        array1.push("&url=" + encodeURIComponent(args.data.url));
                                    }
                                }

                                if (args.data.storageTags != null && args.data.storageTags.length > 0)
                                {
                                    array1.push("&tags=" + encodeURIComponent(args.data.storageTags));
                                }

                                if ("custom" in args.response) {
                                    args.response.custom(array1);
                                    return;
                                }

                                $.ajax({
                                    url: createURL("createStoragePool" + array1.join("")),
                                    dataType: "json",
                                    success: function (json) {
                                        var item = json.createstoragepoolresponse.storagepool;
                                        args.response.success({
                                            data: item
                                        });
                                    },
                                    error: function (XMLHttpResponse) {
                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                        args.response.error(errorMsg);
                                    }
                                });
                            },

                            notification: {
                                poll: function (args) {
                                    args.complete({
                                        actionFilter: primarystorageActionfilter
                                    });
                                }
                            },

                            messages: {
                                notification: function (args) {
                                    return 'label.add.primary.storage';
                                }
                            }
                        },
                        viewMetrics: {
                            label: 'label.metrics',
                            isHeader: true,
                            addRow: false,
                            action: {
                                custom: cloudStack.uiCustom.metricsView({resource: 'storagepool'})
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.metrics';
                                }
                            }
                        }
                    },

                    detailView: {
                        name: "Primary storage details",
                        viewAll: {
                            label: 'label.volumes',
                            path: 'storage.volumes'
                        },
                        isMaximized: true,
                        actions: {
                            edit: {
                                label: 'label.edit',
                                action: function (args) {
                                    var array1 =[];
                                    array1.push("&tags=" + encodeURIComponent(args.data.tags));

                                    if (args.data.disksizetotal != null && args.data.disksizetotal.length > 0) {
                                        var diskSizeTotal = args.data.disksizetotal.split(",").join("");

                                        array1.push("&capacitybytes=" + cloudStack.converters.toBytes(diskSizeTotal));
                                    }

                                    if (args.data.capacityiops != null && args.data.capacityiops.length > 0) {
                                        var capacityIops = args.data.capacityiops.split(",").join("");

                                        array1.push("&capacityiops=" + capacityIops);
                                    }

                                    if (args.data.name != null && args.data.name.length > 0)
                                        array1.push("&name=" + args.data.name);

                                    $.ajax({
                                        url: createURL("updateStoragePool&id=" + args.context.primarystorages[0].id + array1.join("")),
                                        dataType: "json",
                                        success: function (json) {
                                            var item = json.updatestoragepoolresponse.storagepool;
                                            args.response.success({
                                                data: item
                                            });
                                        },
                                        error: function (XMLHttpResponse) {
                                            args.response.error(parseXMLHttpResponse(XMLHttpResponse));
                                        }
                                    });
                                }
                            },

                            enableMaintenanceMode: {
                                label: 'label.action.enable.maintenance.mode',
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("enableStorageMaintenance&id=" + args.context.primarystorages[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.prepareprimarystorageformaintenanceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.storagepool;
                                                    },
                                                    getActionFilter: function () {
                                                        return primarystorageActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.primarystorage.enable.maintenance.mode';
                                    },
                                    notification: function (args) {
                                        return 'label.action.enable.maintenance.mode';
                                    }
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            cancelMaintenanceMode: {
                                label: 'label.action.cancel.maintenance.mode',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.action.cancel.maintenance.mode';
                                    },
                                    notification: function (args) {
                                        return 'label.action.cancel.maintenance.mode';
                                    }
                                },
                                action: function (args) {
                                    $.ajax({
                                        url: createURL("cancelStorageMaintenance&id=" + args.context.primarystorages[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var jid = json.cancelprimarystoragemaintenanceresponse.jobid;
                                            args.response.success({
                                                _custom: {
                                                    jobId: jid,
                                                    getUpdatedItem: function (json) {
                                                        return json.queryasyncjobresultresponse.jobresult.storagepool;
                                                    },
                                                    getActionFilter: function () {
                                                        return primarystorageActionfilter;
                                                    }
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: pollAsyncJobResult
                                }
                            },

                            'remove': {
                                label: 'label.action.delete.primary.storage',
                                messages: {
                                    notification: function (args) {
                                        return 'label.action.delete.primary.storage';
                                    }
                                },
                                createForm: {
                                    title: 'label.action.delete.primary.storage',
                                    fields: {
                                        isForced: {
                                            label: 'force.remove',
                                            isBoolean: true
                                        }
                                    }
                                },
                                action: function (args) {
                                    var array1 =[];
                                    array1.push("&forced=" + (args.data.isForced == "on"));
                                    $.ajax({
                                        url: createURL("deleteStoragePool&id=" + args.context.primarystorages[0].id + array1.join("")),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            args.response.success({
                                                data: {
                                                }
                                            });
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            }
                        },

                        tabs: {
                            details: {
                                title: 'label.details',
                                fields:[ {
                                    name: {
                                        label: 'label.name',
                                        isEditable: true
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    state: {
                                        label: 'label.state'
                                    },
                                    tags: {
                                        label: 'label.storage.tags',
                                        isTokenInput : true,
                                        isEditable: true,
                                        dataProvider: function(args) {
                                            $.ajax({
                                                url: createURL("listStorageTags"),
                                                dataType: "json",
                                                success: function(json) {
                                                    var item = json.liststoragetagsresponse.storagetag;
                                                    var tags = [];

                                                    if (item != null)
                                                    {
                                                        tags = $.map(item, function(tag) {
                                                            return {
                                                                       id: tag.name,
                                                                       name: tag.name
                                                                   };
                                                        });
                                                    }

                                                    args.response.success({
                                                        data: tags,
                                                        hintText: _l('hint.type.part.storage.tag'),
                                                        noResultsText: _l('hint.no.storage.tags')
                                                    });
                                                },
                                                error: function(XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        }
                                    },
                                    zonename: {
                                        label: 'label.zone'
                                    },
                                    podname: {
                                        label: 'label.pod'
                                    },
                                    clustername: {
                                        label: 'label.cluster'
                                    },
                                    type: {
                                        label: 'label.type'
                                    },
                                    ipaddress: {
                                        label: 'label.ip.address'
                                    },
                                    path: {
                                        label: 'label.path'
                                    },
                                    disksizetotal: {
                                        label: 'label.disk.total',
                                        isEditable: true,
                                        converter: function (args) {
                                            if (args == null || args == 0)
                                            return ""; else
                                            return cloudStack.converters.convertBytes(args);
                                        }
                                    },
                                    disksizeallocated: {
                                        label: 'label.disk.allocated',
                                        converter: function (args) {
                                            if (args == null || args == 0)
                                            return ""; else
                                            return cloudStack.converters.convertBytes(args);
                                        }
                                    },
                                    capacityiops: {
                                        label: 'label.disk.iops.total',
                                        isEditable: true,
                                        converter: function (args) {
                                            if (args == null || args == 0)
                                            return ""; else
                                            return args;
                                        }
                                    },
                                    allocatediops: {
                                        label: 'label.disk.iops.allocated',
                                        isEditable: false,
                                        converter: function (args) {
                                            if (args == null || args == 0)
                                            return ""; else
                                            return args;
                                        }
                                    }
                                }],

                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL("listStoragePools&id=" + args.context.primarystorages[0].id),
                                        dataType: "json",
                                        async: true,
                                        success: function (json) {
                                            var item = json.liststoragepoolsresponse.storagepool[0];
                                            args.response.success({
                                                actionFilter: primarystorageActionfilter,
                                                data: item
                                            });
                                        }
                                    });
                                }
                            },

                            // Granular settings for storage pool
                            settings: {
                                title: 'label.settings',
                                custom: cloudStack.uiCustom.granularSettings({
                                    dataProvider: function (args) {

                                        $.ajax({
                                            url: createURL('listConfigurations&storageid=' + args.context.primarystorages[0].id),
                                            data: listViewDataProvider(args, {
                                            },
                                            {
                                                searchBy: 'name'
                                            }),
                                            success: function (json) {
                                                args.response.success({
                                                    data: json.listconfigurationsresponse.configuration
                                                });
                                            },

                                            error: function (json) {
                                                args.response.error(parseXMLHttpResponse(json));
                                            }
                                        });
                                    },
                                    actions: {
                                        edit: function (args) {
                                            // call updateStorageLevelParameters
                                            var data = {
                                                name: args.data.jsonObj.name,
                                                value: args.data.value
                                            };

                                            $.ajax({
                                                url: createURL('updateConfiguration&storageid=' + args.context.primarystorages[0].id),
                                                data: data,
                                                success: function (json) {
                                                    var item = json.updateconfigurationresponse.configuration;
                                                    args.response.success({
                                                        data: item
                                                    });
                                                },

                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        }
                                    }
                                })
                            }
                        }
                    }
                }
            },

            ucs: {
                title: 'UCS',
                id: 'ucs',
                listView: {
                    id: 'ucsManagers',
                    fields: {
                        name: {
                            label: 'label.name'
                        },
                        url: {
                            label: 'label.url'
                        }
                    },
                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL('listUcsManagers'),
                            data: {
                                zoneid: args.context.physicalResources[0].id
                            },
                            success: function (json) {
                                //for testing only (begin)
                                /*
                                json =
                                {
                                "listucsmanagerreponse": {
                                "count": 1,
                                "ucsmanager": [
                                {
                                "id": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                "name": "ucsmanager",
                                "url": "10.223.184.2",
                                "zoneid": "54c9a65c-ba89-4380-96e9-1d429c5372e3"
                                }
                                ]
                                }
                                };
                                 */
                                //for testing only (end)

                                var items = json.listucsmanagerreponse.ucsmanager;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },
                    actions: {
                        add: {
                            label: 'label.add.ucs.manager',

                            messages: {
                                notification: function (args) {
                                    return 'label.add.ucs.manager';
                                }
                            },

                            createForm: {
                                title: 'label.add.ucs.manager',
                                fields: {
                                    name: {
                                        label: 'label.name',
                                        validation: {
                                            required: false
                                        }
                                    },
                                    url: {
                                        label: 'label.ip', //CLOUDSTACK-4629
                                        validation: {
                                            required: true
                                        }
                                    },
                                    username: {
                                        label: 'label.username',
                                        validation: {
                                            required: true
                                        }
                                    },
                                    password: {
                                        label: 'label.password',
                                        isPassword: true,
                                        validation: {
                                            required: true
                                        }
                                    }
                                }
                            },

                            action: function (args) {
                                var data = {
                                    zoneid: args.context.physicalResources[0].id,
                                    url: args.data.url,
                                    username: args.data.username,
                                    password: args.data.password
                                };
                                if (args.data.name != null && args.data.name.length > 0) {
                                    $.extend(data, {
                                        name: args.data.name
                                    });
                                }

                                $.ajax({
                                    url: createURL('addUcsManager'),
                                    data: data,
                                    type: "POST",
                                    success: function (json) {
                                        //e.g. json == { "addUcsManagerResponse" :  { "ucsmanager" : {"id":"11","name":"ucsmanager","url":"10.223.184.2","zoneid":"2"} }  }
                                        var item = json.addUcsManagerResponse.ucsmanager;
                                        args.response.success({
                                            data: item
                                        });
                                    },
                                    error: function (data) {
                                        args.response.error(parseXMLHttpResponse(data));
                                    }
                                });
                            },

                            notification: {
                                poll: function (args) {
                                    args.complete();
                                }
                            }
                        }
                    },

                    detailView: {
                        isMaximized: true,
                        noCompact: true,
                        actions: {
                            remove: {
                                label: 'label.delete.ucs.manager',
                                messages: {
                                    confirm: function (args) {
                                        return 'message.confirm.delete.ucs.manager';
                                    },
                                    notification: function (args) {
                                        return 'label.delete.ucs.manager';
                                    }
                                },
                                action: function (args) {
                                    var data = {
                                        ucsmanagerid: args.context.ucsManagers[0].id
                                    };
                                    $.ajax({
                                        url: createURL('deleteUcsManager'),
                                        data: data,
                                        success: function (json) {
                                            args.response.success();
                                        },
                                        error: function (data) {
                                            args.response.error(parseXMLHttpResponse(data));
                                        }
                                    });
                                },
                                notification: {
                                    poll: function (args) {
                                        args.complete();
                                    }
                                }
                            }
                        },
                        tabs: {
                            details: {
                                title: 'label.details',

                                fields:[ {
                                    name: {
                                        label: 'label.name'
                                    }
                                },
                                {
                                    id: {
                                        label: 'label.id'
                                    },
                                    url: {
                                        label: 'label.url'
                                    }
                                }],

                                dataProvider: function (args) {
                                    $.ajax({
                                        url: createURL('listUcsManagers'),
                                        data: {
                                            id: args.context.ucsManagers[0].id
                                        },
                                        success: function (json) {
                                            //for testing only (begin)
                                            /*
                                            json =
                                            {
                                            "listucsmanagerreponse": {
                                            "count": 1,
                                            "ucsmanager": [
                                            {
                                            "id": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                            "name": "ucsmanager",
                                            "url": "10.223.184.2",
                                            "zoneid": "54c9a65c-ba89-4380-96e9-1d429c5372e3"
                                            }
                                            ]
                                            }
                                            };
                                             */
                                            //for testing only (end)

                                            var item = json.listucsmanagerreponse.ucsmanager[0];
                                            args.response.success({
                                                data: item
                                            });
                                        }
                                    });
                                }
                            },

                            blades: {
                                title: 'label.blades',
                                listView: {
                                    id: 'blades',
                                    hideSearchBar: true,
                                    fields: {
                                        chassis: {
                                            label: 'label.chassis'
                                        },
                                        bladeid: {
                                            label: 'label.blade.id'
                                        },
                                        profiledn: {
                                            label: 'label.associated.profile'
                                        }
                                    },
                                    dataProvider: function (args) {
                                        $.ajax({
                                            url: createURL('listUcsBlades'),
                                            data: {
                                                ucsmanagerid: args.context.ucsManagers[0].id
                                            },
                                            success: function (json) {
                                                //for testing only (begin)
                                                /*
                                                json = {
                                                "listucsbladeresponse": {
                                                "count": 4,
                                                "ucsblade": [
                                                {
                                                "id": "84edb958-cf8a-4e71-99c6-190ccc3fe2bd",
                                                "ucsmanagerid": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                                "bladedn": "sys/chassis-1/blade-1",
                                                "profiledn": "org-root/ls-profile-for-blade-1"
                                                },
                                                {
                                                "id": "524a3e55-5b61-4561-9464-1b19e3543189",
                                                "ucsmanagerid": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                                "bladedn": "sys/chassis-1/blade-2",
                                                "profiledn": "org-root/ls-profile-for-blade-2"
                                                },
                                                {
                                                "id": "4828f560-6191-46e6-8a4c-23d1d7d017f0",
                                                "ucsmanagerid": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                                "bladedn": "sys/chassis-1/blade-3"
                                                },
                                                {
                                                "id": "80ab25c8-3dcf-400e-8849-84dc5e1e6594",
                                                "ucsmanagerid": "07b5b813-83ed-4859-952c-c95cafb63ac4",
                                                "bladedn": "sys/chassis-1/blade-4"
                                                }
                                                ]
                                                }
                                                };
                                                 */
                                                //for testing only (end)

                                                var items = json.listucsbladeresponse.ucsblade ? json.listucsbladeresponse.ucsblade:[];
                                                for (var i = 0; i < items.length; i++) {
                                                    addExtraPropertiesToUcsBladeObject(items[i]);
                                                }
                                                args.response.success({
                                                    actionFilter: bladeActionfilter,
                                                    data: items
                                                });
                                            }
                                        });
                                    },
                                    actions: {
                                        refreshUcsBlades: {
                                            isHeader: true,
                                            label: 'label.refresh.blades',
                                            messages: {
                                                confirm: function (args) {
                                                    return 'message.confirm.refresh.blades';
                                                },
                                                notification: function (args) {
                                                    return 'label.refresh.blades';
                                                }
                                            },
                                            action: function (args) {
                                                $.ajax({
                                                    url: createURL('refreshUcsBlades'),
                                                    data: {
                                                        ucsmanagerid: args.context.ucsManagers[0].id
                                                    },
                                                    success: function (json) {
                                                        $(window).trigger('cloudStack.fullRefresh');
                                                    }
                                                });
                                            },
                                            notification: {
                                                poll: function (args) {
                                                    args.complete();
                                                }
                                            }
                                        },

                                        associateTemplateToBlade: {
                                            label: 'label.instanciate.template.associate.profile.blade',
                                            addRow: 'false',
                                            messages: {
                                                notification: function (args) {
                                                    return 'label.instanciate.template.associate.profile.blade';
                                                }
                                            },
                                            createForm: {
                                                title: 'label.instanciate.template.associate.profile.blade',
                                                fields: {
                                                    templatedn: {
                                                        label: 'label.select.template',
                                                        select: function (args) {
                                                            var items =[];

                                                            $.ajax({
                                                                url: createURL('listUcsTemplates'),
                                                                data: {
                                                                    ucsmanagerid: args.context.ucsManagers[0].id
                                                                },
                                                                async: false,
                                                                success: function (json) {
                                                                    //for testing only (begin)
                                                                    /*
                                                                    json = {
                                                                    "listucstemplatesresponse": {
                                                                    "count": 1,
                                                                    "ucstemplate": [
                                                                    {
                                                                    "ucsdn": "org-root/ls-test"
                                                                    }
                                                                    ]
                                                                    }
                                                                    };
                                                                     */
                                                                    //for testing only (end)

                                                                    var ucstemplates = json.listucstemplatesresponse.ucstemplate;
                                                                    if (ucstemplates != null) {
                                                                        for (var i = 0; i < ucstemplates.length; i++) {
                                                                            items.push({
                                                                                id: ucstemplates[i].ucsdn,
                                                                                description: ucstemplates[i].ucsdn
                                                                            });
                                                                        }
                                                                    }
                                                                }
                                                            });

                                                            args.response.success({
                                                                data: items
                                                            });
                                                        },
                                                        validation: {
                                                            required: true
                                                        }
                                                    },
                                                    profilename: {
                                                        label: 'label.profile'
                                                    }
                                                }
                                            },
                                            action: function (args) {
                                                var data = {
                                                    ucsmanagerid: args.context.ucsManagers[0].id,
                                                    templatedn: args.data.templatedn,
                                                    bladeid: args.context.blades[0].id
                                                };

                                                if (args.data.profilename != null && args.data.profilename.length > 0) {
                                                    $.extend(data, {
                                                        profilename: args.data.profilename
                                                    });
                                                }

                                                $.ajax({
                                                    url: createURL('instantiateUcsTemplateAndAssocaciateToBlade'),
                                                    data: data,
                                                    success: function (json) {
                                                        //for testing only (begin)
                                                        /*
                                                        json = {
                                                        "instantiateucstemplateandassociatetobladeresponse": {
                                                        "jobid": "cd9d0282-4dae-463f-80b6-451e168e2e92"
                                                        }
                                                        }
                                                         */
                                                        //for testing only (end)

                                                        var jid = json.instantiateucstemplateandassociatetobladeresponse.jobid;
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jid,
                                                                getUpdatedItem: function (json) {
                                                                    //for testing only (begin)
                                                                    /*
                                                                    json = {
                                                                    "queryasyncjobresultresponse": {
                                                                    "accountid": "970b694a-2f8c-11e3-a77d-000c29b36ff5",
                                                                    "userid": "970b7b4f-2f8c-11e3-a77d-000c29b36ff5",
                                                                    "cmd": "org.apache.cloudstack.api.InstantiateUcsTemplateAndAssociateToBladeCmd",
                                                                    "jobstatus": 1,
                                                                    "jobprocstatus": 0,
                                                                    "jobresultcode": 0,
                                                                    "jobresulttype": "object",
                                                                    "jobresult": {
                                                                    "ucsblade": {
                                                                    "id": "3d491c6e-f0b6-40b0-bf6e-f89efdd73c30",
                                                                    "ucsmanagerid": "9a34c186-12fa-4bbc-af04-5f1a2bf7ae4a",
                                                                    "bladedn": "sys/chassis-1/blade-3",
                                                                    "profiledn": "org-root/ls-xxxx"
                                                                    }
                                                                    },
                                                                    "created": "2013-10-10T17:29:00-0700",
                                                                    "jobid": "cd9d0282-4dae-463f-80b6-451e168e2e92"
                                                                    }
                                                                    };
                                                                     */
                                                                    //for testing only (end)

                                                                    addExtraPropertiesToUcsBladeObject(json.queryasyncjobresultresponse.jobresult.ucsblade);
                                                                    return json.queryasyncjobresultresponse.jobresult.ucsblade;
                                                                }
                                                            }
                                                        });
                                                    }
                                                });
                                            },
                                            notification: {
                                                poll: pollAsyncJobResult
                                            }
                                        },

                                        disassociateProfileFromBlade: {
                                            label: 'label.disassociate.profile.blade',
                                            addRow: 'false',
                                            messages: {
                                                notification: function (args) {
                                                    return 'label.disassociate.profile.blade';
                                                }
                                            },
                                            createForm: {
                                                title: 'label.disassociate.profile.blade',
                                                fields: {
                                                    deleteprofile: {
                                                        label: 'label.delete.profile',
                                                        isBoolean: true,
                                                        isChecked: true
                                                    }
                                                }
                                            },
                                            action: function (args) {
                                                $.ajax({
                                                    url: createURL('disassociateUcsProfileFromBlade'),
                                                    data: {
                                                        bladeid: args.context.blades[0].id,
                                                        deleteprofile: (args.data.deleteprofile == 'on' ? true: false)
                                                    },
                                                    success: function (json) {
                                                        //for testing only (begin)
                                                        /*
                                                        json = {
                                                        "disassociateucsprofilefrombladeresponse": {
                                                        "jobid": "e371592e-31be-4e53-9346-a5c565d420df"
                                                        }
                                                        }
                                                         */
                                                        //for testing only (end)

                                                        var jid = json.disassociateucsprofilefrombladeresponse.jobid;
                                                        args.response.success({
                                                            _custom: {
                                                                jobId: jid,
                                                                getUpdatedItem: function (json) {
                                                                    //for testing only (begin)
                                                                    /*
                                                                    json = {
                                                                    "queryasyncjobresultresponse": {
                                                                    "accountid": "835fb2d5-0b76-11e3-9350-f4f3e49b5dfe",
                                                                    "userid": "835fc0e5-0b76-11e3-9350-f4f3e49b5dfe",
                                                                    "cmd": "org.apache.cloudstack.api.DisassociateUcsProfileCmd",
                                                                    "jobstatus": 1,
                                                                    "jobprocstatus": 0,
                                                                    "jobresultcode": 0,
                                                                    "jobresulttype": "object",
                                                                    "jobresult": {
                                                                    "ucsblade": {
                                                                    "id": "f8d08575-7a1c-4f79-a588-d129c38bcc4f",
                                                                    "ucsmanagerid": "0d87c1a6-5664-425c-9024-2ddd9605d260",
                                                                    "bladedn": "sys/chassis-1/blade-1"
                                                                    }
                                                                    },
                                                                    "created": "2013-09-13T22:17:29-0700",
                                                                    "jobid": "2c3698a8-39ac-43e6-8ade-86eb2d3726a0"
                                                                    }
                                                                    };
                                                                     */
                                                                    //for testing only (end)

                                                                    addExtraPropertiesToUcsBladeObject(json.queryasyncjobresultresponse.jobresult.ucsblade);
                                                                    return json.queryasyncjobresultresponse.jobresult.ucsblade;
                                                                }
                                                            }
                                                        });
                                                    }
                                                });
                                            },
                                            notification: {
                                                poll: pollAsyncJobResult
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            },

            'secondary-storage': {
                title: 'label.secondary.storage',
                id: 'secondarystorages',
                sectionSelect: {
                    label: 'label.select-view'
                },
                sections: {
                    secondaryStorage: {
                        type: 'select',
                        title: 'label.secondary.storage',
                        listView: {
                            id: 'secondarystorages',
                            section: 'seconary-storage',
                            fields: {
                                name: {
                                    label: 'label.name'
                                },
                                url: {
                                    label: 'label.url'
                                },
                                protocol: {
                                    label: 'label.protocol'
                                },
                                scope: {
                                    label: 'label.scope'
                                },
                                zonename: {
                                    label: 'label.zone'
                                }
                            },


                            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;
                                        }
                                    }
                                }
                                array1.push("&zoneid=" + args.context.zones[0].id);

                                $.ajax({
                                    url: createURL("listImageStores&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        var items = json.listimagestoresresponse.imagestore;
                                        args.response.success({
                                            actionFilter: secondarystorageActionfilter,
                                            data: items
                                        });
                                    }
                                });
                            },

                            actions: {
                                add: {
                                    label: 'label.add.secondary.storage',

                                    createForm: {
                                        title: 'label.add.secondary.storage',

                                        fields: {
                                            name: {
                                                label: 'label.name'
                                            },
                                            provider: {
                                                label: 'label.provider',
                                                select: function (args) {
                                                    /*
                                                    UI no longer gets providers from "listStorageProviders&type=image" because:
                                                    (1) Not all of returned values are handled by UI.
                                                    (2) Provider "SMB" which is handled by UI is not returned from "listStorageProviders&type=image"
                                                     */
                                                    var items =[ {
                                                        id: 'NFS',
                                                        description: 'NFS'
                                                    },
                                                    {
                                                        id: 'SMB',
                                                        description: 'SMB/CIFS'
                                                    },
                                                    {
                                                        id: 'S3',
                                                        description: 'S3'
                                                    },
                                                    {
                                                        id: 'Swift',
                                                        description: 'Swift'
                                                    }];

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

                                                    args.$select.change(function () {
                                                        var $form = $(this).closest('form');
                                                        if ($(this).val() == "NFS") {
                                                            //NFS, SMB
                                                            $form.find('.form-item[rel=zoneid]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=nfsServer]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=path]').css('display', 'inline-block');

                                                            //SMB
                                                            $form.find('.form-item[rel=smbUsername]').hide();
                                                            $form.find('.form-item[rel=smbPassword]').hide();
                                                            $form.find('.form-item[rel=smbDomain]').hide();

                                                            //S3
                                                            $form.find('.form-item[rel=accesskey]').hide();
                                                            $form.find('.form-item[rel=secretkey]').hide();
                                                            $form.find('.form-item[rel=bucket]').hide();
                                                            $form.find('.form-item[rel=endpoint]').hide();
                                                            $form.find('.form-item[rel=usehttps]').hide();
                                                            $form.find('.form-item[rel=connectiontimeout]').hide();
                                                            $form.find('.form-item[rel=maxerrorretry]').hide();
                                                            $form.find('.form-item[rel=sockettimeout]').hide();

                                                            $form.find('.form-item[rel=createNfsCache]').find('input').prop('checked', false);
                                                            $form.find('.form-item[rel=createNfsCache]').hide();
                                                            $form.find('.form-item[rel=nfsCacheZoneid]').hide();
                                                            $form.find('.form-item[rel=nfsCacheNfsServer]').hide();
                                                            $form.find('.form-item[rel=nfsCachePath]').hide();

                                                            //Swift
                                                            $form.find('.form-item[rel=url]').hide();
                                                            $form.find('.form-item[rel=account]').hide();
                                                            $form.find('.form-item[rel=username]').hide();
                                                            $form.find('.form-item[rel=key]').hide();
                                                            $form.find('.form-item[rel=storagepolicy]').hide();
                                                        } else if ($(this).val() == "SMB") {
                                                            //NFS, SMB
                                                            $form.find('.form-item[rel=zoneid]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=nfsServer]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=path]').css('display', 'inline-block');

                                                            //SMB
                                                            $form.find('.form-item[rel=smbUsername]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=smbPassword]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=smbDomain]').css('display', 'inline-block');

                                                            //S3
                                                            $form.find('.form-item[rel=accesskey]').hide();
                                                            $form.find('.form-item[rel=secretkey]').hide();
                                                            $form.find('.form-item[rel=bucket]').hide();
                                                            $form.find('.form-item[rel=endpoint]').hide();
                                                            $form.find('.form-item[rel=usehttps]').hide();
                                                            $form.find('.form-item[rel=connectiontimeout]').hide();
                                                            $form.find('.form-item[rel=maxerrorretry]').hide();
                                                            $form.find('.form-item[rel=sockettimeout]').hide();

                                                            $form.find('.form-item[rel=createNfsCache]').find('input').prop('checked', false);
                                                            $form.find('.form-item[rel=createNfsCache]').hide();
                                                            $form.find('.form-item[rel=nfsCacheZoneid]').hide();
                                                            $form.find('.form-item[rel=nfsCacheNfsServer]').hide();
                                                            $form.find('.form-item[rel=nfsCachePath]').hide();

                                                            //Swift
                                                            $form.find('.form-item[rel=url]').hide();
                                                            $form.find('.form-item[rel=account]').hide();
                                                            $form.find('.form-item[rel=username]').hide();
                                                            $form.find('.form-item[rel=key]').hide();
                                                            $form.find('.form-item[rel=storagepolicy]').hide();
                                                        } else if ($(this).val() == "S3") {
                                                            //NFS, SMB
                                                            $form.find('.form-item[rel=zoneid]').hide();
                                                            $form.find('.form-item[rel=nfsServer]').hide();
                                                            $form.find('.form-item[rel=path]').hide();

                                                            //SMB
                                                            $form.find('.form-item[rel=smbUsername]').hide();
                                                            $form.find('.form-item[rel=smbPassword]').hide();
                                                            $form.find('.form-item[rel=smbDomain]').hide();

                                                            //S3
                                                            $form.find('.form-item[rel=accesskey]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=secretkey]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=bucket]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=endpoint]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=usehttps]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=connectiontimeout]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=maxerrorretry]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=sockettimeout]').css('display', 'inline-block');

                                                            $form.find('.form-item[rel=createNfsCache]').find('input').attr('checked', 'checked');
                                                            //$form.find('.form-item[rel=createNfsCache]').find('input').attr('disabled', 'disabled');  //This checkbox should not be disabled any more because NFS staging (of a zone) might already exist (from "NFS secondary storage => Prepare Object Store Migration => NFS staging")
                                                            $form.find('.form-item[rel=createNfsCache]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=nfsCacheZoneid]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=nfsCacheNfsServer]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=nfsCachePath]').css('display', 'inline-block');


                                                            //Swift
                                                            $form.find('.form-item[rel=url]').hide();
                                                            $form.find('.form-item[rel=account]').hide();
                                                            $form.find('.form-item[rel=username]').hide();
                                                            $form.find('.form-item[rel=key]').hide();
                                                            $form.find('.form-item[rel=storagepolicy]').hide();
                                                        } else if ($(this).val() == "Swift") {
                                                            //NFS, SMB
                                                            $form.find('.form-item[rel=zoneid]').hide();
                                                            $form.find('.form-item[rel=nfsServer]').hide();
                                                            $form.find('.form-item[rel=path]').hide();

                                                            //SMB
                                                            $form.find('.form-item[rel=smbUsername]').hide();
                                                            $form.find('.form-item[rel=smbPassword]').hide();
                                                            $form.find('.form-item[rel=smbDomain]').hide();

                                                            //S3
                                                            $form.find('.form-item[rel=accesskey]').hide();
                                                            $form.find('.form-item[rel=secretkey]').hide();
                                                            $form.find('.form-item[rel=bucket]').hide();
                                                            $form.find('.form-item[rel=endpoint]').hide();
                                                            $form.find('.form-item[rel=usehttps]').hide();
                                                            $form.find('.form-item[rel=connectiontimeout]').hide();
                                                            $form.find('.form-item[rel=maxerrorretry]').hide();
                                                            $form.find('.form-item[rel=sockettimeout]').hide();

                                                            $form.find('.form-item[rel=createNfsCache]').find('input').prop('checked', false);
                                                            $form.find('.form-item[rel=createNfsCache]').hide();
                                                            $form.find('.form-item[rel=nfsCacheZoneid]').hide();
                                                            $form.find('.form-item[rel=nfsCacheNfsServer]').hide();
                                                            $form.find('.form-item[rel=nfsCachePath]').hide();

                                                            //Swift
                                                            $form.find('.form-item[rel=url]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=account]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=username]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=key]').css('display', 'inline-block');
                                                            $form.find('.form-item[rel=storagepolicy]').css('display', 'inline-block');
                                                        }
                                                    });

                                                    args.$select.change();
                                                }
                                            },


                                            //NFS, SMB (begin)
                                            zoneid: {
                                                label: 'label.zone',
                                                docID: 'helpSecondaryStorageZone',
                                                validation: {
                                                    required: true
                                                },
                                                select: function (args) {
                                                    $.ajax({
                                                        url: createURL('listZones'),
                                                        data: {},
                                                        success: function (json) {
                                                            var zones = json.listzonesresponse.zone ? json.listzonesresponse.zone:[];

                                                            if (zones != null) {
                                                                //$.map(items, fn) - items can not be null
                                                                args.response.success({
                                                                    data: $.map(zones, function (zone) {
                                                                        return {
                                                                            id: zone.id,
                                                                            description: zone.name
                                                                        };
                                                                    })
                                                                });
                                                            } else {
                                                                args.response.success({
                                                                    data: null
                                                                });
                                                            }
                                                        }
                                                    });
                                                }
                                            },
                                            nfsServer: {
                                                label: 'label.server', //change label from "NFS Server" to "Server" since this field is also shown when provider "SMB/CIFS" is elected.
                                                docID: 'helpSecondaryStorageNFSServer',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            path: {
                                                label: 'label.path',
                                                docID: 'helpSecondaryStoragePath',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            //NFS, SMB (end)


                                            //SMB (begin)
                                            smbUsername: {
                                                label: 'label.smb.username',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            smbPassword: {
                                                label: 'label.smb.password',
                                                isPassword: true,
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            smbDomain: {
                                                label: 'label.smb.domain',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            //SMB (end)

                                            //S3 (begin)
                                            accesskey: {
                                                label: 'label.s3.access_key',
                                                docID: 'helpS3AccessKey',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            secretkey: {
                                                label: 'label.s3.secret_key',
                                                docID: 'helpS3SecretKey',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            bucket: {
                                                label: 'label.s3.bucket',
                                                docID: 'helpS3Bucket',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            endpoint: {
                                                label: 'label.s3.endpoint',
                                                docID: 'helpS3Endpoint'
                                            },
                                            usehttps: {
                                                label: 'label.s3.use_https',
                                                isEditable: true,
                                                isBoolean: true,
                                                isChecked: true,
                                                converter: cloudStack.converters.toBooleanText
                                            },
                                            connectiontimeout: {
                                                label: 'label.s3.connection_timeout',
                                                docID: 'helpS3ConnectionTimeout'
                                            },
                                            maxerrorretry: {
                                                label: 'label.s3.max_error_retry',
                                                docID: 'helpS3MaxErrorRetry'
                                            },
                                            sockettimeout: {
                                                label: 'label.s3.socket_timeout',
                                                docID: 'helpS3SocketTimeout'
                                            },

                                            createNfsCache: {
                                                label: 'label.create.nfs.secondary.staging.store',
                                                isBoolean: true,
                                                isChecked: true
                                            },
                                            nfsCacheZoneid: {
                                                dependsOn: 'createNfsCache',
                                                label: 'label.zone',
                                                validation: {
                                                    required: true
                                                },
                                                select: function (args) {
                                                    $.ajax({
                                                        url: createURL('listZones'),
                                                        data: {},
                                                        success: function (json) {
                                                            var zones = json.listzonesresponse.zone;

                                                            if (zones != null) {
                                                                //$.map(items, fn) - items can not be null
                                                                args.response.success({
                                                                    data: $.map(zones, function (zone) {
                                                                        return {
                                                                            id: zone.id,
                                                                            description: zone.name
                                                                        };
                                                                    })
                                                                });
                                                            } else {
                                                                args.response.success({
                                                                    data: null
                                                                });
                                                            }
                                                        }
                                                    });
                                                }
                                            },
                                            nfsCacheNfsServer: {
                                                dependsOn: 'createNfsCache',
                                                label: 'label.nfs.server',
                                                docID: 'helpNFSStagingServer',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            nfsCachePath: {
                                                dependsOn: 'createNfsCache',
                                                label: 'label.path',
                                                docID: 'helpNFSStagingPath',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            //S3 (end)


                                            //Swift (begin)
                                            url: {
                                                label: 'label.url',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            account: {
                                                label: 'label.account',
                                                 validation: {
                                                     required: true
                                                 }
                                            },
                                            username: {
                                                label: 'label.username',
                                                 validation: {
                                                     required: true
                                                 }
                                            },
                                            key: {
                                                label: 'label.key',
                                                 validation: {
                                                     required: true
                                                 }
                                            },
                                             storagepolicy: {
                                                 label: 'label.storagepolicy'
                                             }
                                            //Swift (end)
                                        }
                                    },

                                    action: function (args) {
                                        var data = {
                                        };
                                        if (args.data.name != null && args.data.name.length > 0) {
                                            $.extend(data, {
                                                name: args.data.name
                                            });
                                        }

                                        if (args.data.provider == 'NFS') {
                                            var zoneid = args.data.zoneid;
                                            var nfs_server = args.data.nfsServer;
                                            var path = args.data.path;
                                            var url = nfsURL(nfs_server, path);

                                            $.extend(data, {
                                                provider: args.data.provider,
                                                zoneid: zoneid,
                                                url: url
                                            });

                                            $.ajax({
                                                url: createURL('addImageStore'),
                                                data: data,
                                                success: function (json) {
                                                    var item = json.addimagestoreresponse.imagestore;
                                                    args.response.success({
                                                        data: item
                                                    });
                                                },
                                                error: function (XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        } else if (args.data.provider == 'SMB') {
                                            var zoneid = args.data.zoneid;
                                            var nfs_server = args.data.nfsServer;
                                            var path = args.data.path;
                                            var url = smbURL(nfs_server, path);
                                            $.extend(data, {
                                                provider: args.data.provider,
                                                zoneid: zoneid,
                                                url: url,
                                                'details[0].key': 'user',
                                                'details[0].value': args.data.smbUsername,
                                                'details[1].key': 'password',
                                                'details[1].value': args.data.smbPassword,
                                                'details[2].key': 'domain',
                                                'details[2].value': args.data.smbDomain
                                            });

                                            $.ajax({
                                                url: createURL('addImageStore'),
                                                data: data,
                                                success: function (json) {
                                                    var item = json.addimagestoreresponse.imagestore;
                                                    args.response.success({
                                                        data: item
                                                    });
                                                },
                                                error: function (XMLHttpResponse) {
                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                    args.response.error(errorMsg);
                                                }
                                            });
                                        } else if (args.data.provider == 'S3') {
                                            $.extend(data, {
                                                provider: args.data.provider,
                                                'details[0].key': 'accesskey',
                                                'details[0].value': args.data.accesskey,
                                                'details[1].key': 'secretkey',
                                                'details[1].value': args.data.secretkey,
                                                'details[2].key': 'bucket',
                                                'details[2].value': args.data.bucket,
                                                'details[3].key': 'usehttps',
                                                'details[3].value': (args.data.usehttps != null && args.data.usehttps == 'on' ? 'true': 'false')
                                            });

                                            var index = 4;
                                            if (args.data.endpoint != null && args.data.endpoint.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'endpoint';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.endpoint;
                                                index++;
                                            }
                                            if (args.data.connectiontimeout != null && args.data.connectiontimeout.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'connectiontimeout';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.connectiontimeout;
                                                index++;
                                            }
                                            if (args.data.maxerrorretry != null && args.data.maxerrorretry.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'maxerrorretry';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.maxerrorretry;
                                                index++;
                                            }
                                            if (args.data.sockettimeout != null && args.data.sockettimeout.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'sockettimeout';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.sockettimeout;
                                                index++;
                                            }

                                            $.ajax({
                                                url: createURL('addImageStore'),
                                                data: data,
                                                success: function (json) {
                                                    g_regionsecondaryenabled = true;

                                                    var item = json.addimagestoreresponse.imagestore;
                                                    args.response.success({
                                                        data: item
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });

                                            if (args.data.createNfsCache == 'on') {
                                                var zoneid = args.data.nfsCacheZoneid;
                                                var nfs_server = args.data.nfsCacheNfsServer;
                                                var path = args.data.nfsCachePath;
                                                var url = nfsURL(nfs_server, path);

                                                var nfsCacheData = {
                                                    provider: 'NFS',
                                                    zoneid: zoneid,
                                                    url: url
                                                };

                                                $.ajax({
                                                    url: createURL('createSecondaryStagingStore'),
                                                    data: nfsCacheData,
                                                    success: function (json) {
                                                        //do nothing
                                                    },
                                                    error: function (json) {
                                                        args.response.error(parseXMLHttpResponse(json));
                                                    }
                                                });
                                            }
                                        } else if (args.data.provider == 'Swift') {
                                            $.extend(data, {
                                                provider: args.data.provider,
                                                url: args.data.url
                                            });

                                            var index = 0;
                                            if (args.data.account != null && args.data.account.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'account';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.account;
                                                index++;
                                            }
                                            if (args.data.username != null && args.data.username.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'username';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.username;
                                                index++;
                                            }
                                            if (args.data.key != null && args.data.key.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'key';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.key;
                                                index++;
                                            }
                                            if (args.data.storagepolicy != null && args.data.storagepolicy.length > 0) {
                                                data[ 'details[' + index.toString() + '].key'] = 'storagepolicy';
                                                data[ 'details[' + index.toString() + '].value'] = args.data.storagepolicy;
                                                index++;
                                            }
                                            $.ajax({
                                                url: createURL('addImageStore'),
                                                data: data,
                                                success: function (json) {
                                                    g_regionsecondaryenabled = true;

                                                    var item = json.addimagestoreresponse.imagestore;
                                                    args.response.success({
                                                        data: item
                                                    });
                                                },
                                                error: function (json) {
                                                    args.response.error(parseXMLHttpResponse(json));
                                                }
                                            });
                                        }
                                    },

                                    notification: {
                                        poll: function (args) {
                                            args.complete({
                                                actionFilter: secondarystorageActionfilter
                                            });
                                        }
                                    },

                                    messages: {
                                        notification: function (args) {
                                            return 'label.add.secondary.storage';
                                        }
                                    }
                                }
                            },

                            detailView: {
                                name: 'label.secondary.storage.details',
                                isMaximized: true,
                                actions: {
                                    remove: {
                                        label: 'label.action.delete.secondary.storage',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.action.delete.secondary.storage';
                                            },
                                            notification: function (args) {
                                                return 'label.action.delete.secondary.storage';
                                            }
                                        },
                                        action: function (args) {
                                            $.ajax({
                                                url: createURL("deleteImageStore&id=" + args.context.secondaryStorage[0].id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    args.response.success();
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete({
                                                    data: {
                                                        resourcestate: 'Destroyed'
                                                    }
                                                });
                                            }
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.details',
                                        fields:[ {
                                            name: {
                                                label: 'label.name'
                                            }
                                        },
                                        {
                                            url: {
                                                label: 'label.url'
                                            },
                                            protocol: {
                                                label: 'label.protocol'
                                            },
                                            providername: {
                                                label: 'label.provider'
                                            },
                                            scope: {
                                                label: 'label.scope'
                                            },
                                            zonename: {
                                                label: 'label.zone'
                                            },
                                            id: {
                                                label: 'label.id'
                                            }
                                        }],

                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL("listImageStores&id=" + args.context.secondaryStorage[0].id),
                                                dataType: "json",
                                                async: true,
                                                success: function (json) {
                                                    var item = json.listimagestoresresponse.imagestore[0];
                                                    processPropertiesInImagestoreObject(item);
                                                    args.response.success({
                                                        actionFilter: secondarystorageActionfilter,
                                                        data: item
                                                    });
                                                }
                                            });
                                        }
                                    },

                                    // Granular settings for image store
									settings: {
										title: 'label.settings',
										custom: cloudStack.uiCustom.granularSettings({
											dataProvider: function (args) {

												$.ajax({
													url: createURL('listConfigurations&imagestoreuuid=' + args.context.secondaryStorage[0].id),
													data: listViewDataProvider(args, {
													},
													{
														searchBy: 'name'
													}),
													success: function (json) {
														args.response.success({
															data: json.listconfigurationsresponse.configuration
														});
													},

													error: function (json) {
														args.response.error(parseXMLHttpResponse(json));
													}
												});
											},
											actions: {
												edit: function (args) {
													// call updateStorageLevelParameters
													var data = {
														name: args.data.jsonObj.name,
														value: args.data.value
													};

													$.ajax({
														url: createURL('updateConfiguration&imagestoreuuid=' + args.context.secondaryStorage[0].id),
														data: data,
														success: function (json) {
															var item = json.updateconfigurationresponse.configuration;
															args.response.success({
																data: item
															});
														},

														error: function (json) {
															args.response.error(parseXMLHttpResponse(json));
														}
													});
												}
											}
										})
									}
                                }
                            }
                        }
                    },
                    cacheStorage: {
                        type: 'select',
                        title: 'label.secondary.staging.store',
                        listView: {
                            id: 'secondarystorages',
                            section: 'seconary-storage',
                            fields: {
                                name: {
                                    label: 'label.name'
                                },
                                url: {
                                    label: 'label.url'
                                },
                                providername: {
                                    label: 'label.provider'
                                }
                            },

                            /*
                            dataProvider: function(args) {  //being replaced with dataProvider in line 6898
                            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;
                            }
                            }
                            }
                            array1.push("&zoneid=" + args.context.zones[0].id);

                            $.ajax({
                            url: createURL("listImageStores&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
                            dataType: "json",
                            async: true,
                            success: function(json) {
                            var items = json.listimagestoreresponse.imagestore;
                            args.response.success({
                            actionFilter: secondarystorageActionfilter,
                            data:items
                            });
                            }
                            });
                            },
                             */

                            actions: {
                                add: {
                                    label: 'label.add.nfs.secondary.staging.store',
                                    createForm: {
                                        title: 'label.add.nfs.secondary.staging.store',
                                        fields: {
                                            zoneid: {
                                                label: 'label.zone',
                                                validation: {
                                                    required: true
                                                },
                                                select: function (args) {
                                                    $.ajax({
                                                        url: createURL('listZones'),
                                                        data: {},
                                                        success: function (json) {
                                                            var zones = json.listzonesresponse.zone ? json.listzonesresponse.zone:[];

                                                            if (zones != null) {
                                                                //$.map(items, fn) - items can not be null
                                                                args.response.success({
                                                                    data: $.map(zones, function (zone) {
                                                                        return {
                                                                            id: zone.id,
                                                                            description: zone.name
                                                                        };
                                                                    })
                                                                });
                                                            } else {
                                                                args.response.success({
                                                                    data: null
                                                                });
                                                            }
                                                        }
                                                    });
                                                }
                                            },
                                            nfsServer: {
                                                label: 'label.nfs.server',
                                                validation: {
                                                    required: true
                                                }
                                            },
                                            path: {
                                                label: 'label.path',
                                                validation: {
                                                    required: true
                                                }
                                            }
                                        }
                                    },
                                    action: function (args) {
                                        var data = {
                                            provider: 'NFS',
                                            zoneid: args.data.zoneid,
                                            url: nfsURL(args.data.nfsServer, args.data.path)
                                        };
                                        $.ajax({
                                            url: createURL('createSecondaryStagingStore'),
                                            data: data,
                                            success: function (json) {
                                                var item = json.createsecondarystagingstoreresponse.secondarystorage;
                                                args.response.success({
                                                    data: item
                                                });
                                            },
                                            error: function (json) {
                                                args.response.error(parseXMLHttpResponse(json));
                                            }
                                        });
                                    },
                                    notification: {
                                        poll: function (args) {
                                            args.complete();
                                        }
                                    },
                                    messages: {
                                        notification: function (args) {
                                            return 'label.add.nfs.secondary.staging.store';
                                        }
                                    }
                                }
                            },

                            detailView: {
                                name: 'label.secondary.staging.store.details',
                                isMaximized: true,
                                actions: {
                                    remove: {
                                        label: 'label.delete.secondary.staging.store',
                                        messages: {
                                            confirm: function (args) {
                                                return 'message.confirm.delete.secondary.staging.store';
                                            },
                                            notification: function (args) {
                                                return 'label.delete.secondary.staging.store';
                                            }
                                        },
                                        action: function (args) {
                                            var data = {
                                                id: args.context.cacheStorage[0].id
                                            };
                                            $.ajax({
                                                url: createURL('deleteSecondaryStagingStore'),
                                                data: data,
                                                async: true,
                                                success: function (json) {
                                                    args.response.success();
                                                },
                                                error: function (data) {
                                                    args.response.error(parseXMLHttpResponse(data));
                                                }
                                            });
                                        },
                                        notification: {
                                            poll: function (args) {
                                                args.complete();
                                            }
                                        }
                                    }
                                },
                                tabs: {
                                    details: {
                                        title: 'label.details',
                                        fields:[ {
                                            name: {
                                                label: 'label.name'
                                            }
                                        },
                                        {
                                            url: {
                                                label: 'label.url'
                                            },
                                            providername: {
                                                label: 'label.provider'
                                            },
                                            scope: {
                                                label: 'label.scope'
                                            },
                                            zonename: {
                                                label: 'label.zone'
                                            },
                                            details: {
                                                label: 'label.details',
                                                converter: function (array1) {
                                                    var string1 = '';
                                                    if (array1 != null) {
                                                        for (var i = 0; i < array1.length; i++) {
                                                            if (i > 0)
                                                            string1 += ', ';

                                                            string1 += array1[i].name + ': ' + array1[i].value;
                                                        }
                                                    }
                                                    return string1;
                                                }
                                            },
                                            id: {
                                                label: 'label.id'
                                            }
                                        }],

                                        dataProvider: function (args) {
                                            $.ajax({
                                                url: createURL('listSecondaryStagingStores'),
                                                data: {
                                                    id: args.context.cacheStorage[0].id
                                                },
                                                async: false,
                                                success: function (json) {
                                                    var item = json.listsecondarystagingstoreresponse.imagestore[0];
                                                    args.response.success({
                                                        data: item
                                                    });
                                                }
                                            });
                                        }
                                    }

                                    // Granular settings for storage pool for secondary storage is not required
                                    /*  settings: {
                                    title: 'label.menu.global.settings',
                                    custom: cloudStack.uiCustom.granularSettings({
                                    dataProvider: function(args) {
                                    args.response.success({
                                    data: [
                                    { name: 'config.param.1', value: 1 },
                                    { name: 'config.param.2', value: 2 }
                                    ]
                                    });
                                    },
                                    actions: {
                                    edit: function(args) {
                                    // call updateStorageLevelParameters
                                    args.response.success();
                                    }
                                    }
                                    })
                                    } */
                                }
                            }
                        }
                    }
                }
            },

            guestIpRanges: {
                //Advanced zone - Guest traffic type - Network tab - Network detailView - View IP Ranges
                title: 'label.guest.ip.range',
                id: 'guestIpRanges',
                listView: {
                    section: 'guest-IP-range',
                    fields: {
                        startip: {
                            label: 'label.ipv4.start.ip'
                        },
                        endip: {
                            label: 'label.ipv4.end.ip'
                        },
                        startipv6: {
                            label: 'label.ipv6.start.ip'
                        },
                        endipv6: {
                            label: 'label.ipv6.end.ip'
                        },
                        gateway: {
                            label: 'label.gateway'
                        },
                        netmask: {
                            label: 'label.netmask'
                        }
                    },

                    dataProvider: function (args) {
                        $.ajax({
                            url: createURL("listVlanIpRanges&zoneid=" + selectedZoneObj.id + "&networkid=" + args.context.networks[0].id + "&page=" + args.page + "&pagesize=" + pageSize),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var items = json.listvlaniprangesresponse.vlaniprange;
                                args.response.success({
                                    data: items
                                });
                            }
                        });
                    },

                    actions: {
                        add: {
                            label: 'label.add.ip.range',
                            createForm: {
                                title: 'label.add.ip.range',
                                fields: {
                                    gateway: {
                                        label: 'label.gateway'
                                    },
                                    netmask: {
                                        label: 'label.netmask'
                                    },
                                    startipv4: {
                                        label: 'label.ipv4.start.ip'
                                    },
                                    endipv4: {
                                        label: 'label.ipv4.end.ip'
                                    },
                                    ip6cidr: {
                                        label: 'label.ipv6.CIDR'
                                    },
                                    ip6gateway: {
                                        label: 'label.ipv6.gateway'
                                    },
                                    startipv6: {
                                        label: 'label.ipv6.start.ip'
                                    },
                                    endipv6: {
                                        label: 'label.ipv6.end.ip'
                                    }
                                }
                            },
                            action: function (args) {
                                var array2 =[];

                                if (args.data.gateway != null && args.data.gateway.length > 0)
                                array2.push("&gateway=" + args.data.gateway);
                                if (args.data.netmask != null && args.data.netmask.length > 0)
                                array2.push("&netmask=" + args.data.netmask);

                                if (args.data.startipv4 != null && args.data.startipv4.length > 0)
                                array2.push("&startip=" + args.data.startipv4);
                                if (args.data.endipv4 != null && args.data.endipv4.length > 0)
                                array2.push("&endip=" + args.data.endipv4);

                                if (args.data.ip6cidr != null && args.data.ip6cidr.length > 0)
                                array2.push("&ip6cidr=" + args.data.ip6cidr);
                                if (args.data.ip6gateway != null && args.data.ip6gateway.length > 0)
                                array2.push("&ip6gateway=" + args.data.ip6gateway);

                                if (args.data.startipv6 != null && args.data.startipv6.length > 0)
                                array2.push("&startipv6=" + args.data.startipv6);
                                if (args.data.endipv6 != null && args.data.endipv6.length > 0)
                                array2.push("&endipv6=" + args.data.endipv6);

                                $.ajax({
                                    url: createURL("createVlanIpRange&forVirtualNetwork=false&networkid=" + args.context.networks[0].id + array2.join("")),
                                    dataType: "json",
                                    success: function (json) {
                                        var item = json.createvlaniprangeresponse.vlan;
                                        args.response.success({
                                            data: item
                                        });
                                    },
                                    error: function (XMLHttpResponse) {
                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                        args.response.error(errorMsg);
                                    }
                                });
                            },
                            notification: {
                                poll: function (args) {
                                    args.complete();
                                }
                            },
                            messages: {
                                notification: function (args) {
                                    return 'label.add.ip.range';
                                }
                            }
                        },

                        'remove': {
                            label: 'label.remove.ip.range',
                            messages: {
                                confirm: function (args) {
                                    return 'message.confirm.remove.IP.range';
                                },
                                notification: function (args) {
                                    return 'label.remove.ip.range';
                                }
                            },
                            action: function (args) {
                                $.ajax({
                                    url: createURL("deleteVlanIpRange&id=" + args.data.id),
                                    dataType: "json",
                                    async: true,
                                    success: function (json) {
                                        args.response.success({
                                            data: {
                                            }
                                        });
                                    },
                                    error: function (json) {
                                        args.response.error(parseXMLHttpResponse(json));
                                    }
                                });
                            },
                            notification: {
                                poll: function (args) {
                                    args.complete();
                                }
                            }
                        }
                    }
                }
            }
        }
    };

    function addBaremetalDhcpDeviceFn(args) {
        if (nspMap[ "BaremetalDhcpProvider"] == null) {
            $.ajax({
                url: createURL("addNetworkServiceProvider&name=BaremetalDhcpProvider&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                dataType: "json",
                async: true,
                success: function (json) {
                    var jobId = json.addnetworkserviceproviderresponse.jobid;
                    var addBaremetalDhcpProviderIntervalID = setInterval(function () {
                        $.ajax({
                            url: createURL("queryAsyncJobResult&jobId=" + jobId),
                            dataType: "json",
                            success: function (json) {
                                var result = json.queryasyncjobresultresponse;
                                if (result.jobstatus == 0) {
                                    return; //Job has not completed
                                } else {
                                    clearInterval(addBaremetalDhcpProviderIntervalID);
                                    if (result.jobstatus == 1) {
                                        nspMap[ "BaremetalDhcpProvider"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;

                                        $.ajax({
                                            url: createURL('addBaremetalDhcp'),
                                            data: {
                                                physicalnetworkid: selectedPhysicalNetworkObj.id,
                                                dhcpservertype: 'DHCPD',
                                                url: args.data.url,
                                                username: args.data.username,
                                                password: args.data.password
                                            },
                                            type: "POST",
                                            success: function (json) {
                                                var jid = json.addbaremetaldhcpresponse.jobid;
                                                args.response.success({
                                                    _custom: {
                                                        jobId: jid,
                                                        getUpdatedItem: function (json) {
                                                            var item = json.queryasyncjobresultresponse.jobresult.baremetaldhcp;
                                                            return item;
                                                        }
                                                    }
                                                });
                                            }
                                        });
                                    } else if (result.jobstatus == 2) {
                                        alert(_s(result.jobresult.errortext));
                                    }
                                }
                            },
                            error: function (XMLHttpResponse) {
                                alert(parseXMLHttpResponse(XMLHttpResponse));
                            }
                        });
                    },
                    g_queryAsyncJobResultInterval);
                }
            });
        } else {
            $.ajax({
                url: createURL('addBaremetalDhcp'),
                data: {
                    physicalnetworkid: selectedPhysicalNetworkObj.id,
                    dhcpservertype: 'DHCPD',
                    url: args.data.url,
                    username: args.data.username,
                    password: args.data.password
                },
                type: "POST",
                success: function (json) {
                    var jid = json.addbaremetaldhcpresponse.jobid;
                    args.response.success({
                        _custom: {
                            jobId: jid,
                            getUpdatedItem: function (json) {
                                var item = json.queryasyncjobresultresponse.jobresult.baremetaldhcp;
                                return item;
                            }
                        }
                    });
                }
            });
        }
    }

    function addBaremetalPxeDeviceFn(args) {
        if (nspMap[ "BaremetalPxeProvider"] == null) {
            $.ajax({
                url: createURL("addNetworkServiceProvider&name=BaremetalPxeProvider&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                dataType: "json",
                async: true,
                success: function (json) {
                    var jobId = json.addnetworkserviceproviderresponse.jobid;
                    var addBaremetalPxeProviderIntervalID = setInterval(function () {
                        $.ajax({
                            url: createURL("queryAsyncJobResult&jobId=" + jobId),
                            dataType: "json",
                            success: function (json) {
                                var result = json.queryasyncjobresultresponse;
                                if (result.jobstatus == 0) {
                                    return; //Job has not completed
                                } else {
                                    clearInterval(addBaremetalPxeProviderIntervalID);
                                    if (result.jobstatus == 1) {
                                        nspMap[ "BaremetalPxeProvider"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;

                                        $.ajax({
                                            url: createURL('addBaremetalPxeKickStartServer'),
                                            data: {
                                                physicalnetworkid: selectedPhysicalNetworkObj.id,
                                                pxeservertype: 'KICK_START',
                                                url: args.data.url,
                                                username: args.data.username,
                                                password: args.data.password,
                                                tftpdir: args.data.tftpdir
                                            },
                                            type: "POST",
                                            success: function (json) {
                                                var jid = json.addbaremetalpxeresponse.jobid;
                                                args.response.success({
                                                    _custom: {
                                                        jobId: jid,
                                                        getUpdatedItem: function (json) {
                                                            var item = json.queryasyncjobresultresponse.jobresult.baremetalpxeserver;
                                                            return item;
                                                        }
                                                    }
                                                });
                                            }
                                        });
                                    } else if (result.jobstatus == 2) {
                                        alert(_s(result.jobresult.errortext));
                                    }
                                }
                            },
                            error: function (XMLHttpResponse) {
                                alert(parseXMLHttpResponse(XMLHttpResponse));
                            }
                        });
                    },
                    g_queryAsyncJobResultInterval);
                }
            });
        } else {
            $.ajax({
                url: createURL('addBaremetalPxeKickStartServer'),
                data: {
                    physicalnetworkid: selectedPhysicalNetworkObj.id,
                    pxeservertype: 'KICK_START',
                    url: args.data.url,
                    username: args.data.username,
                    password: args.data.password,
                    tftpdir: args.data.tftpdir
                },
                type: "POST",
                success: function (json) {
                    var jid = json.addbaremetalpxeresponse.jobid;
                    args.response.success({
                        _custom: {
                            jobId: jid,
                            getUpdatedItem: function (json) {
                                var item = json.queryasyncjobresultresponse.jobresult.baremetalpxeserver;
                                return item;
                            }
                        }
                    });
                }
            });
        }
    }

    // Inject cloudStack infra page
    cloudStack.sections.system.show = cloudStack.uiCustom.physicalResources(cloudStack.sections.system.physicalResourceSection);

    function addExternalLoadBalancer(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.username, args.data.password);
        array1.push("&networkdevicetype=" + encodeURIComponent(args.data.networkdevicetype));

        if (apiCmd == "addNetscalerLoadBalancer") {
            array1.push("&gslbprovider=" + (args.data.gslbprovider == "on"));
            array1.push("&gslbproviderpublicip=" + encodeURIComponent(args.data.gslbproviderpublicip));
            array1.push("&gslbproviderprivateip=" + encodeURIComponent(args.data.gslbproviderprivateip));
        }

        //construct URL starts here
        var url =[];

        var ip = args.data.ip;
        url.push("https://" + ip);

        var isQuestionMarkAdded = false;

        var publicInterface = args.data.publicinterface;
        if (publicInterface != null && publicInterface.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("publicinterface=" + publicInterface);
        }

        var privateInterface = args.data.privateinterface;
        if (privateInterface != null && privateInterface.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("privateinterface=" + privateInterface);
        }

        var numretries = args.data.numretries;
        if (numretries != null && numretries.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("numretries=" + numretries);
        }

        var isInline = args.data.inline;
        if (isInline != null && isInline.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("inline=" + isInline);
        }

        var capacity = args.data.capacity;
        if (capacity != null && capacity.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("lbdevicecapacity=" + capacity);
        }

        var dedicated = (args.data.dedicated == "on");
        //boolean    (true/false)
        if (isQuestionMarkAdded == false) {
            url.push("?");
            isQuestionMarkAdded = true;
        } else {
            url.push("&");
        }
        url.push("lbdevicededicated=" + dedicated.toString());


        array1.push("&url=" + encodeURIComponent(url.join("")));
        //construct URL ends here

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addExternalFirewall(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.username, args.data.password);
        array1.push("&networkdevicetype=" + encodeURIComponent(args.data.networkdevicetype));

        //construct URL starts here
        var url =[];

        var ip = args.data.ip;
        url.push("https://" + ip);

        var isQuestionMarkAdded = false;

        var publicInterface = args.data.publicinterface;
        if (publicInterface != null && publicInterface.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("publicinterface=" + publicInterface);
        }

        var privateInterface = args.data.privateinterface;
        if (privateInterface != null && privateInterface.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("privateinterface=" + privateInterface);
        }

        var usageInterface = args.data.usageinterface;
        if (usageInterface != null && usageInterface.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("usageinterface=" + usageInterface);
        }

        var numretries = args.data.numretries;
        if (numretries != null && numretries.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("numretries=" + numretries);
        }

        var timeout = args.data.timeout;
        if (timeout != null && timeout.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("timeout=" + timeout);
        }

        var isInline = args.data.inline;
        if (isInline != null && isInline.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("inline=" + isInline);
        }

        var publicNetwork = args.data.publicnetwork;
        if (publicNetwork != null && publicNetwork.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("publicnetwork=" + publicNetwork);
        }

        var privateNetwork = args.data.privatenetwork;
        if (privateNetwork != null && privateNetwork.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("privatenetwork=" + privateNetwork);
        }

        var capacity = args.data.capacity;
        if (capacity != null && capacity.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("fwdevicecapacity=" + capacity);
        }

        var dedicated = (args.data.dedicated == "on");
        //boolean    (true/false)
        if (isQuestionMarkAdded == false) {
            url.push("?");
            isQuestionMarkAdded = true;
        } else {
            url.push("&");
        }
        url.push("fwdevicededicated=" + dedicated.toString());

        // START - Palo Alto Specific Fields
        var externalVirtualRouter = args.data.pavr;
        if (externalVirtualRouter != null && externalVirtualRouter.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("pavr=" + encodeURIComponent(externalVirtualRouter));
        }

        var externalThreatProfile = args.data.patp;
        if (externalThreatProfile != null && externalThreatProfile.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("patp=" + encodeURIComponent(externalThreatProfile));
        }

        var externalLogProfile = args.data.palp;
        if (externalLogProfile != null && externalLogProfile.length > 0) {
            if (isQuestionMarkAdded == false) {
                url.push("?");
                isQuestionMarkAdded = true;
            } else {
                url.push("&");
            }
            url.push("palp=" + encodeURIComponent(externalLogProfile));
        }
        // END - Palo Alto Specific Fields

        array1.push("&url=" + encodeURIComponent(url.join("")));
        //construct URL ends here

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addNiciraNvpDevice(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, rgs.data.username, args.data.password);
        array1.push("&hostname=" + encodeURIComponent(args.data.host));
        array1.push("&transportzoneuuid=" + encodeURIComponent(args.data.transportzoneuuid));

        var l3GatewayServiceUuid = args.data.l3gatewayserviceuuid;
        if (l3GatewayServiceUuid != null && l3GatewayServiceUuid.length > 0) {
            array1.push("&l3gatewayserviceuuid=" + encodeURIComponent(args.data.l3gatewayserviceuuid));
        }

		var l2GatewayServiceUuid = args.data.l2gatewayserviceuuid;
        if (l2GatewayServiceUuid != null && l2GatewayServiceUuid.length > 0) {
            array1.push("&l2gatewayserviceuuid=" + encodeURIComponent(args.data.l2gatewayserviceuuid));
        }

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addBrocadeVcsDevice(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.username, args.data.password);
        array1.push("&hostname=" + encodeURIComponent(args.data.host));

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addOpenDaylightController(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.username, args.data.password);
        array1.push("&url=" + encodeURIComponent(args.data.url));

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addBigSwitchBcfDevice(args, physicalNetworkObj, apiCmd, apiCmdRes, apiCmdObj) {
        var array1 =[];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        array1.push("&hostname=" + encodeURIComponent(args.data.host));
        array1.push("&username=" + encodeURIComponent(args.data.username));
        cloudStack.addPasswordToCommandUrlParameterArray(array1, args.data.password);
        array1.push("&nat=" + (args.data.nat == 'on' ? "true": "false"));

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            success: function (json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid,
                        getUpdatedItem: function (json) {
                            var item = json.queryasyncjobresultresponse.jobresult[apiCmdObj];

                            return item;
                        }
                    }
                });
            }
        });
    }

    function addGloboDnsHost(args, physicalNetworkObj, apiCmd, apiCmdRes) {
        var array1 = [];
        array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
        cloudStack.addUsernameAndPasswordToCommandUrlParameterArrayIfItIsNotNullAndNotEmpty(array1, args.data.username, args.data.password);
        array1.push("&url=" + encodeURIComponent(args.data.url));

        $.ajax({
            url: createURL(apiCmd + array1.join("")),
            dataType: "json",
            type: "POST",
            success: function(json) {
                var jid = json[apiCmdRes].jobid;
                args.response.success({
                    _custom: {
                        jobId: jid
                    }
                });
            }
        });
    }


    var afterCreateZonePhysicalNetworkTrafficTypes = function (args, newZoneObj, newPhysicalnetwork) {
                $.ajax({
            url: createURL("updatePhysicalNetwork&state=Enabled&id=" + newPhysicalnetwork.id),
            dataType: "json",
            success: function (json) {
                var jobId = json.updatephysicalnetworkresponse.jobid;
                var enablePhysicalNetworkIntervalID = setInterval(function () {
                    $.ajax({
                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                        dataType: "json",
                        success: function (json) {
                            var result = json.queryasyncjobresultresponse;
                            if (result.jobstatus == 0) {
                                return; //Job has not completed
                            } else {
                                clearInterval(enablePhysicalNetworkIntervalID);
                                if (result.jobstatus == 1) {
                                    //alert("updatePhysicalNetwork succeeded.");

                                    // get network service provider ID of Virtual Router
                                    var virtualRouterProviderId;
                                    $.ajax({
                                        url: createURL("listNetworkServiceProviders&name=VirtualRouter&physicalNetworkId=" + newPhysicalnetwork.id),
                                        dataType: "json",
                                        async: false,
                                        success: function (json) {
                                            var items = json.listnetworkserviceprovidersresponse.networkserviceprovider;
                                            if (items != null && items.length > 0) {
                                                virtualRouterProviderId = items[0].id;
                                            }
                                        }
                                    });
                                    if (virtualRouterProviderId == null) {
                                        alert("error: listNetworkServiceProviders API doesn't return VirtualRouter provider ID");
                                        return;
                                    }

                                    var virtualRouterElementId;
                                    $.ajax({
                                        url: createURL("listVirtualRouterElements&nspid=" + virtualRouterProviderId),
                                        dataType: "json",
                                        async: false,
                                        success: function (json) {
                                            var items = json.listvirtualrouterelementsresponse.virtualrouterelement;
                                            if (items != null && items.length > 0) {
                                                virtualRouterElementId = items[0].id;
                                            }
                                        }
                                    });
                                    if (virtualRouterElementId == null) {
                                        alert("error: listVirtualRouterElements API doesn't return Virtual Router Element Id");
                                        return;
                                    }

                                    $.ajax({
                                        url: createURL("configureVirtualRouterElement&enabled=true&id=" + virtualRouterElementId),
                                        dataType: "json",
                                        async: false,
                                        success: function (json) {
                                            var jobId = json.configurevirtualrouterelementresponse.jobid;
                                            var enableVirtualRouterElementIntervalID = setInterval(function () {
                                                $.ajax({
                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                    dataType: "json",
                                                    success: function (json) {
                                                        var result = json.queryasyncjobresultresponse;
                                                        if (result.jobstatus == 0) {
                                                            return; //Job has not completed
                                                        } else {
                                                            clearInterval(enableVirtualRouterElementIntervalID);
                                                            if (result.jobstatus == 1) {
                                                                //alert("configureVirtualRouterElement succeeded.");

                                                                $.ajax({
                                                                    url: createURL("updateNetworkServiceProvider&state=Enabled&id=" + virtualRouterProviderId),
                                                                    dataType: "json",
                                                                    async: false,
                                                                    success: function (json) {
                                                                        var jobId = json.updatenetworkserviceproviderresponse.jobid;
                                                                        var enableVirtualRouterProviderIntervalID = setInterval(function () {
                                                                            $.ajax({
                                                                                url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                                                dataType: "json",
                                                                                success: function (json) {
                                                                                    var result = json.queryasyncjobresultresponse;
                                                                                    if (result.jobstatus == 0) {
                                                                                        return; //Job has not completed
                                                                                    } else {
                                                                                        clearInterval(enableVirtualRouterProviderIntervalID);
                                                                                        if (result.jobstatus == 1) {
                                                                                            //alert("Virtual Router Provider is enabled");

                                                                                            if (newZoneObj.networktype == "Basic") {
                                                                                                if (args.data[ "security-groups-enabled"] == "on") {
                                                                                                    //need to Enable security group provider first
                                                                                                    // get network service provider ID of Security Group
                                                                                                    var securityGroupProviderId;
                                                                                                    $.ajax({
                                                                                                        url: createURL("listNetworkServiceProviders&name=SecurityGroupProvider&physicalNetworkId=" + newPhysicalnetwork.id),
                                                                                                        dataType: "json",
                                                                                                        async: false,
                                                                                                        success: function (json) {
                                                                                                            var items = json.listnetworkserviceprovidersresponse.networkserviceprovider;
                                                                                                            if (items != null && items.length > 0) {
                                                                                                                securityGroupProviderId = items[0].id;
                                                                                                            }
                                                                                                        }
                                                                                                    });
                                                                                                    if (securityGroupProviderId == null) {
                                                                                                        alert("error: listNetworkServiceProviders API doesn't return security group provider ID");
                                                                                                        return;
                                                                                                    }

                                                                                                    $.ajax({
                                                                                                        url: createURL("updateNetworkServiceProvider&state=Enabled&id=" + securityGroupProviderId),
                                                                                                        dataType: "json",
                                                                                                        async: false,
                                                                                                        success: function (json) {
                                                                                                            var jobId = json.updatenetworkserviceproviderresponse.jobid;
                                                                                                            var enableSecurityGroupProviderIntervalID = setInterval(function () {
                                                                                                                $.ajax({
                                                                                                                    url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                                                                                                    dataType: "json",
                                                                                                                    success: function (json) {
                                                                                                                        var result = json.queryasyncjobresultresponse;
                                                                                                                        if (result.jobstatus == 0) {
                                                                                                                            return; //Job has not completed
                                                                                                                        } else {
                                                                                                                            clearInterval(enableSecurityGroupProviderIntervalID);
                                                                                                                            if (result.jobstatus == 1) {
                                                                                                                                //alert("Security group provider is enabled");

                                                                                                                                //create network (for basic zone only)
                                                                                                                                var array2 =[];
                                                                                                                                array2.push("&zoneid=" + newZoneObj.id);
                                                                                                                                array2.push("&name=guestNetworkForBasicZone");
                                                                                                                                array2.push("&displaytext=guestNetworkForBasicZone");
                                                                                                                                array2.push("&networkofferingid=" + args.data.networkOfferingId);
                                                                                                                                $.ajax({
                                                                                                                                    url: createURL("createNetwork" + array2.join("")),
                                                                                                                                    dataType: "json",
                                                                                                                                    async: false,
                                                                                                                                    success: function (json) {
                                                                                                                                        var arrayOfParameters = cloudStack.createArrayOfParametersForCreatePodCommand(newZoneObj.id, args.data);
                                                                                                                                        $.ajax({
                                                                                                                                            url: createURL("createPod" + arrayOfParameters.join("")),
                                                                                                                                            dataType: "json",
                                                                                                                                            async: false,
                                                                                                                                            success: function (json) {
                                                                                                                                            },
                                                                                                                                            error: function (XMLHttpResponse) {
                                                                                                                                                var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                                                                                                alert("createPod failed. Error: " + errorMsg);
                                                                                                                                            }
                                                                                                                                        });
                                                                                                                                    }
                                                                                                                                });
                                                                                                                            } else if (result.jobstatus == 2) {
                                                                                                                                alert("failed to enable security group provider. Error: " + _s(result.jobresult.errortext));
                                                                                                                            }
                                                                                                                        }
                                                                                                                    },
                                                                                                                    error: function (XMLHttpResponse) {
                                                                                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                                                                        alert("updateNetworkServiceProvider failed. Error: " + errorMsg);
                                                                                                                    }
                                                                                                                });
                                                                                                            },
                                                                                                            g_queryAsyncJobResultInterval);
                                                                                                        }
                                                                                                    });
                                                                                                } else {
                                                                                                    //create network (for basic zone only)
                                                                                                    var array2 =[];
                                                                                                    array2.push("&zoneid=" + newZoneObj.id);
                                                                                                    array2.push("&name=guestNetworkForBasicZone");
                                                                                                    array2.push("&displaytext=guestNetworkForBasicZone");
                                                                                                    array2.push("&networkofferingid=" + args.data.networkOfferingId);
                                                                                                    $.ajax({
                                                                                                        url: createURL("createNetwork" + array2.join("")),
                                                                                                        dataType: "json",
                                                                                                        async: false,
                                                                                                        success: function (json) {
                                                                                                            var arrayOfParameters = cloudStack.createArrayOfParametersForCreatePodCommand(newZoneObj.id, args.data);
                                                                                                            $.ajax({
                                                                                                                url: createURL("createPod" + arrayOfParameters.join("")),
                                                                                                                dataType: "json",
                                                                                                                async: false,
                                                                                                                success: function (json) {
                                                                                                                },
                                                                                                                error: function (XMLHttpResponse) {
                                                                                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                                                                    alert("createPod failed. Error: " + errorMsg);
                                                                                                                }
                                                                                                            });
                                                                                                        }
                                                                                                    });
                                                                                                }
                                                                                            } else {
                                                                                                var arrayOfParameters = cloudStack.createArrayOfParametersForCreatePodCommand(newZoneObj.id, args.data);
                                                                                                $.ajax({
                                                                                                    url: createURL("createPod" + arrayOfParameters.join("")),
                                                                                                    dataType: "json",
                                                                                                    async: false,
                                                                                                    success: function (json) {
                                                                                                    },
                                                                                                    error: function (XMLHttpResponse) {
                                                                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                                                        alert("createPod failed. Error: " + errorMsg);
                                                                                                    }
                                                                                                });
                                                                                            }
                                                                                        } else if (result.jobstatus == 2) {
                                                                                            alert("failed to enable Virtual Router Provider. Error: " + _s(result.jobresult.errortext));
                                                                                        }
                                                                                    }
                                                                                },
                                                                                error: function (XMLHttpResponse) {
                                                                                    var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                                                    alert("updateNetworkServiceProvider failed. Error: " + errorMsg);
                                                                                }
                                                                            });
                                                                        },
                                                                        g_queryAsyncJobResultInterval);
                                                                    }
                                                                });
                                                            } else if (result.jobstatus == 2) {
                                                                alert("configureVirtualRouterElement failed. Error: " + _s(result.jobresult.errortext));
                                                            }
                                                        }
                                                    },
                                                    error: function (XMLHttpResponse) {
                                                        var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                                        alert("configureVirtualRouterElement failed. Error: " + errorMsg);
                                                    }
                                                });
                                            },
                                            g_queryAsyncJobResultInterval);
                                        }
                                    });
                                } else if (result.jobstatus == 2) {
                                    alert("updatePhysicalNetwork failed. Error: " + _s(result.jobresult.errortext));
                                }
                            }
                        },
                        error: function (XMLHttpResponse) {
                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                            alert("updatePhysicalNetwork failed. Error: " + errorMsg);
                        }
                    });
                },
                g_queryAsyncJobResultInterval);
            }
        });
    };

    //action filters (begin)
    var zoneActionfilter = cloudStack.actionFilter.zoneActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[ 'enableSwift'];

        if (jsonObj.vmwaredcId == null) {
            allowedActions.push('addVmwareDc');
        } else {
            allowedActions.push('updateVmwareDc');
            allowedActions.push('removeVmwareDc');
        }

        if (jsonObj.domainid != null)
        allowedActions.push("releaseDedicatedZone"); else
        allowedActions.push("dedicateZone");

        allowedActions.push("edit");

        if (jsonObj.allocationstate == "Disabled")
        allowedActions.push("enable"); else if (jsonObj.allocationstate == "Enabled")
        allowedActions.push("disable");

        allowedActions.push("remove");

        if (jsonObj.hasOwnProperty('resourcedetails') && jsonObj['resourcedetails'].hasOwnProperty('outOfBandManagementEnabled') && jsonObj['resourcedetails']['outOfBandManagementEnabled'] == 'false') {
            allowedActions.push("enableOutOfBandManagement");
        } else {
            allowedActions.push("disableOutOfBandManagement");
        }

        if (jsonObj.hasOwnProperty('resourcedetails') && jsonObj['resourcedetails'].hasOwnProperty('resourceHAEnabled') && jsonObj['resourcedetails']['resourceHAEnabled'] == 'false') {
            allowedActions.push("enableHA");
        } else {
            allowedActions.push("disableHA");
        }

        allowedActions.push("startRollingMaintenance");
        return allowedActions;
    }


    var nexusActionfilter = function (args) {
        var nexusObj = args.context.item;
        var allowedActions =[];
        allowedActions.push("edit");
        if (nexusObj.vsmdevicestate == "Disabled")
        allowedActions.push("enable"); else if (nexusObj.vsmdevicestate == "Enabled")
        allowedActions.push("disable");
        allowedActions.push("remove");
        return allowedActions;
    }

    var podActionfilter = function (args) {
        var podObj = args.context.item;
        var dedicatedPodObj = args.context.podItem;
        var allowedActions =[];

        if (podObj.domainid != null)
        allowedActions.push("release"); else
        allowedActions.push("dedicate");


        allowedActions.push("edit");
        if (podObj.allocationstate == "Disabled")
        allowedActions.push("enable"); else if (podObj.allocationstate == "Enabled")
        allowedActions.push("disable");
        allowedActions.push("remove");

        /*
        var selectedZoneObj;
        $(zoneObjs).each(function(){
        if(this.id == podObj.zoneid) {
        selectedZoneObj = this;
        return false;  //break the $.each() loop
        }
        });
         */

        if (selectedZoneObj.networktype == "Basic") {
            //basic-mode network (pod-wide VLAN)
            //$("#tab_ipallocation, #add_iprange_button, #tab_network_device, #add_network_device_button").show();
            allowedActions.push("addIpRange");
            allowedActions.push("addNetworkDevice");
        } else if (selectedZoneObj.networktype == "Advanced") {
            //advanced-mode network (zone-wide VLAN)
            //$("#tab_ipallocation, #add_iprange_button, #tab_network_device, #add_network_device_button").hide();
        }

        allowedActions.push("startRollingMaintenance");
        return allowedActions;
    }

    var networkDeviceActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];
        return allowedActions;
    }

    var clusterActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        if (jsonObj.domainid != null)
        allowedActions.push("release"); else
        allowedActions.push("dedicate");

        if (jsonObj.state == "Enabled") {
            //managed, allocation enabled
            allowedActions.push("unmanage");
            allowedActions.push("disable");
            //allowedActions.push("edit"); // No fields to edit
        } else if (jsonObj.state == "Disabled") {
            //managed, allocation disabled
            allowedActions.push("unmanage");
            allowedActions.push("enable");
            //allowedActions.push("edit"); // No fields to edit
        } else {
            //Unmanaged, PrepareUnmanaged , PrepareUnmanagedError
            allowedActions.push("manage");
        }

        allowedActions.push("remove");

        if (jsonObj.hasOwnProperty('resourcedetails') && jsonObj['resourcedetails'].hasOwnProperty('outOfBandManagementEnabled') && jsonObj['resourcedetails']['outOfBandManagementEnabled'] == 'false') {
            allowedActions.push("enableOutOfBandManagement");
        } else {
            allowedActions.push("disableOutOfBandManagement");
        }

        if (jsonObj.hasOwnProperty('resourcedetails') && jsonObj['resourcedetails'].hasOwnProperty('resourceHAEnabled') && jsonObj['resourcedetails']['resourceHAEnabled'] == 'false') {
            allowedActions.push("enableHA");
        } else {
            allowedActions.push("disableHA");
        }

        allowedActions.push("startRollingMaintenance");
        return allowedActions;
    }

    var hostActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        if (jsonObj.domainid != null)
        allowedActions.push("release"); else
        allowedActions.push("dedicate");


        if (jsonObj.resourcestate == "Enabled") {
            allowedActions.push("edit");
            allowedActions.push("enableMaintenanceMode");
            allowedActions.push("disable");

            if (jsonObj.state != "Disconnected")
            allowedActions.push("forceReconnect");

            if (jsonObj.hypervisor == "KVM") {
                allowedActions.push("secureKVMHost");
                allowedActions.push("startRollingMaintenance");
            }

        } else if (jsonObj.resourcestate == "ErrorInMaintenance") {
            allowedActions.push("edit");
            allowedActions.push("enableMaintenanceMode");
            allowedActions.push("cancelMaintenanceMode");
            if (jsonObj.hypervisor == "KVM") {
                allowedActions.push("startRollingMaintenance");
            }
        } else if (jsonObj.resourcestate == "PrepareForMaintenance" || jsonObj.resourcestate == 'ErrorInPrepareForMaintenance') {
            allowedActions.push("edit");
            allowedActions.push("cancelMaintenanceMode");
        } else if (jsonObj.resourcestate == "Maintenance") {
            allowedActions.push("edit");
            allowedActions.push("cancelMaintenanceMode");
            allowedActions.push("remove");
        } else if (jsonObj.resourcestate == "Disabled") {
            allowedActions.push("edit");
            allowedActions.push("enable");
            allowedActions.push("remove");
        }

        allowedActions.push("blankHAForHost");
        allowedActions.push("configureHAForHost");
        if (jsonObj.hasOwnProperty("hostha") && jsonObj.hostha.haenable) {
            allowedActions.push("disableHA");
        } else {
            allowedActions.push("enableHA");
        }

        allowedActions.push("blankOutOfBandManagement");
        allowedActions.push("configureOutOfBandManagement");
        if (jsonObj.hasOwnProperty("outofbandmanagement") && jsonObj.outofbandmanagement.enabled) {
            allowedActions.push("issueOutOfBandManagementPowerAction");
            allowedActions.push("changeOutOfBandManagementPassword");
            allowedActions.push("disableOutOfBandManagement");
        } else {
            allowedActions.push("enableOutOfBandManagement");
        }

        if ((jsonObj.state == "Down" || jsonObj.state == "Alert" || jsonObj.state == "Disconnected") && ($.inArray("remove", allowedActions) == -1)) {
            allowedActions.push("remove");
        }

        return allowedActions;
    }

    var primarystorageActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        allowedActions.push("edit");

        if (jsonObj.state == 'Up' || jsonObj.state == "Connecting") {
            allowedActions.push("enableMaintenanceMode");
        } else if (jsonObj.state == 'Down') {
            allowedActions.push("enableMaintenanceMode");
            allowedActions.push("remove");
        } else if (jsonObj.state == "Alert") {
            allowedActions.push("remove");
        } else if (jsonObj.state == "ErrorInMaintenance") {
            allowedActions.push("enableMaintenanceMode");
            allowedActions.push("cancelMaintenanceMode");
        } else if (jsonObj.state == "PrepareForMaintenance" || jsonObj.resourcestate == "ErrorInPrepareForMaintenance") {
            allowedActions.push("cancelMaintenanceMode");
        } else if (jsonObj.state == "Maintenance") {
            allowedActions.push("cancelMaintenanceMode");
            allowedActions.push("remove");
        } else if (jsonObj.state == "Disconnected") {
            allowedActions.push("remove");
        }
        return allowedActions;
    }

    var secondarystorageActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions = [];
        allowedActions.push("remove");
        return allowedActions;
    }

    var routerActionfilter = cloudStack.sections.system.routerActionFilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        if (jsonObj.requiresupgrade == true) {
            allowedActions.push('upgradeRouterToUseNewerTemplate');
        }

        if (jsonObj.state == 'Running') {
            allowedActions.push("stop");

            //when router is Running, only VMware support scaleUp(change service offering)
            if (jsonObj.hypervisor == "VMware") {
                allowedActions.push("scaleUp");
            }

            allowedActions.push("restart");
            allowedActions.push("remove");
            allowedActions.push("viewConsole");

            if (isAdmin()) {
                allowedActions.push("migrate");
                allowedActions.push("diagnostics");
                allowedActions.push("retrieveDiagnostics");
                allowedActions.push("healthChecks");
            }
        } else if (jsonObj.state == 'Stopped') {
            allowedActions.push("start");

            //when router is Stopped, all hypervisors support scaleUp(change service offering)
            allowedActions.push("scaleUp");

            allowedActions.push("remove");
        }
        if (jsonObj.state == 'Starting' || jsonObj.state == 'Stopping' || jsonObj.state == 'Migrating') {
            allowedActions.push("viewConsole");
        }
        return allowedActions;
    }

    var internallbinstanceActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        if (jsonObj.state == 'Running') {
            allowedActions.push("stop");
            allowedActions.push("viewConsole");
            if (isAdmin())
            allowedActions.push("migrate");
        } else if (jsonObj.state == 'Stopped') {
            allowedActions.push("start");
        }
        if (jsonObj.state == 'Starting' || jsonObj.state == 'Stopping' || jsonObj.state == 'Migrating') {
            allowedActions.push("viewConsole");
        }
        return allowedActions;
    }

    var systemvmActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];

        if (jsonObj.state == 'Running') {
            allowedActions.push("stop");
            allowedActions.push("restart");
            allowedActions.push("remove");

            //when systemvm is Running, only VMware support scaleUp(change service offering)
            if (jsonObj.hypervisor == "VMware") {
                allowedActions.push("scaleUp");
            }

            allowedActions.push("viewConsole");
            if (isAdmin()) {
                allowedActions.push("migrate");
                allowedActions.push("diagnostics");
                allowedActions.push("retrieveDiagnostics");
            }
        } else if (jsonObj.state == 'Stopped') {
            allowedActions.push("start");

            //when systemvm is Stopped, all hypervisors support scaleUp(change service offering)
            allowedActions.push("scaleUp");

            allowedActions.push("remove");
        } else if (jsonObj.state == 'Error') {
            allowedActions.push("remove");
        }
        if (jsonObj.state == 'Starting' || jsonObj.state == 'Stopping' || jsonObj.state == 'Migrating') {
            allowedActions.push("viewConsole");
        }
        return allowedActions;
    }

    var routerGroupActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];
        if (jsonObj.routerRequiresUpgrade > 0) {
            allowedActions.push("upgradeRouterToUseNewerTemplate");
        }
        return allowedActions;
    }

    var bladeActionfilter = function (args) {
        var jsonObj = args.context.item;
        var allowedActions =[];
        if (jsonObj.profiledn == null) {
            allowedActions.push("associateTemplateToBlade");
        } else {
            allowedActions.push("disassociateProfileFromBlade");
        }
        return allowedActions;
    }

    //action filters (end)

    var networkProviderActionFilter = function (id) {
        return function (args) {
            var allowedActions =[];
            var jsonObj = nspMap[id] ?
            nspMap[id]: {
            };

            if (id == "netscaler") {
                var netscalerControlCenter = null;

                $.ajax({
                    url: createURL("listNetscalerControlCenter"),
                    dataType: "json",
                    async: false,
                    success: function(json) {
                        var items = json.listNetscalerControlCenter.netscalercontrolcenter;
                        if (items != null && items.length > 0) {
                            netscalerControlCenter = items[0];
                        }
                    }
                });
            }

            if (netscalerControlCenter != null) {
              if (jsonObj.state == undefined) {
                        $.ajax({
                            url: createURL("addNetworkServiceProvider&name=Netscaler&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
                            dataType: "json",
                            async: true,
                            success: function (json) {
                                var jobId = json.addnetworkserviceproviderresponse.jobid;
                                var addNetscalerProviderIntervalID = setInterval(function () {
                                    $.ajax({
                                        url: createURL("queryAsyncJobResult&jobId=" + jobId),
                                        dataType: "json",
                                        success: function (json) {
                                            var result = json.queryasyncjobresultresponse;
                                            if (result.jobstatus == 0) {
                                                return; //Job has not completed
                                            } else {
                                                clearInterval(addNetscalerProviderIntervalID);
                                                if (result.jobstatus == 1) {
                                                    nspMap[ "netscaler"] = result.jobresult.networkserviceprovider;
                                                    addExternalLoadBalancer(args, selectedPhysicalNetworkObj, "addNetscalerLoadBalancer", "addnetscalerloadbalancerresponse", "netscalerloadbalancer");
                                                } else if (result.jobstatus == 2) {
                                                    alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + _s(result.jobresult.errortext));
                                                }
                                            }
                                        },
                                        error: function (XMLHttpResponse) {
                                            var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                            alert("addNetworkServiceProvider&name=Netscaler failed. Error: " + errorMsg);
                                        }
                                    });
                                },
                                g_queryAsyncJobResultInterval);
                            }
                        });
                        jsonObj.state = "Disabled";
                    }
            }

            if (jsonObj.state) {
               if (jsonObj.state == "Enabled")
                 allowedActions.push("disable"); else if (jsonObj.state == "Disabled")
                 allowedActions.push("enable");
                 allowedActions.push("destroy");
            }

            allowedActions.push('add');

            return allowedActions;
        }
    };

    var addExtraPropertiesToClusterObject = function (jsonObj) {
        if (jsonObj.managedstate == "Managed") {
            jsonObj.state = jsonObj.allocationstate; //jsonObj.state == Enabled, Disabled
        } else {
            jsonObj.state = jsonObj.managedstate; //jsonObj.state == Unmanaged, PrepareUnmanaged, PrepareUnmanagedError
        }
    }

    var addExtraPropertiesToRouterInstanceObject = function (jsonObj) {
        if (jsonObj.isredundantrouter == true) {
            jsonObj[ "redundantRouterState"] = jsonObj.redundantstate;
        } else {
            jsonObj[ "redundantRouterState"] = "";
        }
    }

    var refreshNspData = function (nspName) {
        var array1 =[];
        if (nspName != null)
        array1.push("&name=" + nspName);

        $.ajax({
            url: createURL("listNetworkServiceProviders&physicalnetworkid=" + selectedPhysicalNetworkObj.id + array1.join("")),
            dataType: "json",
            async: false,
            success: function (json) {
                nspMap = {
                };
                //reset

                var items = json.listnetworkserviceprovidersresponse.networkserviceprovider;
                if (items != null) {
                    for (var i = 0; i < items.length; i++) {
                        switch (items[i].name) {
                            case "VirtualRouter":
                            nspMap[ "virtualRouter"] = items[i];
                            break;
                            case "InternalLbVm":
                            nspMap[ "InternalLbVm"] = items[i];
                            break;
                            case "VpcVirtualRouter":
                            nspMap[ "vpcVirtualRouter"] = items[i];
                            break;
                            case "Ovs":
                                nspMap["Ovs"] = items[i];
                                break;
                            case "Netscaler":
                            nspMap[ "netscaler"] = items[i];
                            break;
                            case "BaremetalDhcpProvider":
                            nspMap[ "BaremetalDhcpProvider"] = items[i];
                            break;
                            case "BaremetalPxeProvider":
                            nspMap[ "BaremetalPxeProvider"] = items[i];
                            break;
                            case "F5BigIp":
                            nspMap[ "f5"] = items[i];
                            break;
                            case "JuniperSRX":
                            nspMap[ "srx"] = items[i];
                            break;
                            case "PaloAlto":
                            nspMap[ "pa"] = items[i];
                            break;
                            case "SecurityGroupProvider":
                            nspMap[ "securityGroups"] = items[i];
                            break;
                            case "NiciraNvp":
                            nspMap[ "niciraNvp"] = items[i];
                            break;
                            case "BrocadeVcs":
                            nspMap[ "brocadeVcs"] = items[i];
                            break;
                            case "BigSwitchBcf":
                            nspMap[ "bigswitchBcf"] = items[i];
                            break;
                            case "Ovs":
                            nspMap[ "Ovs"] = items[i];
                            break;
                            case "Opendaylight":
                            nspMap[ "Opendaylight"] = items[i];
                            break;
                            case "GloboDns":
                                nspMap["GloboDns"] = items[i];
                                break;
                            case "ConfigDrive":
                                nspMap["ConfigDrive"] = items[i];
                                break;
                        }
                    }
                }
            }
        });

        nspHardcodingArray =[ {
            id: 'netscaler',
            name: 'NetScaler',
            state: nspMap.netscaler ? nspMap.netscaler.state: 'Disabled'
        },
        {
            id: 'virtualRouter',
            name: 'Virtual Router',
            state: nspMap.virtualRouter ? nspMap.virtualRouter.state: 'Disabled'
        },
        {
            id: 'niciraNvp',
            name: 'Nicira Nvp',
            state: nspMap.niciraNvp ? nspMap.niciraNvp.state: 'Disabled'
        },
        {
            id: 'brocadeVcs',
            name: 'Brocade',
            state: nspMap.brocadeVcs ? nspMap.brocadeVcs.state: 'Disabled'
        },
        {
            id: 'bigswitchBcf',
            name: 'BigSwitch BCF',
            state: nspMap.bigswitchBcf ? nspMap.bigswitchBcf.state: 'Disabled'
        },
        {
            id: 'BaremetalDhcpProvider',
            name: 'Baremetal DHCP',
            state: nspMap.BaremetalDhcpProvider ? nspMap.BaremetalDhcpProvider.state: 'Disabled'
        },
        {
            id: 'BaremetalPxeProvider',
            name: 'Baremetal PXE',
            state: nspMap.BaremetalPxeProvider ? nspMap.BaremetalPxeProvider.state: 'Disabled'
        },
        {
            id: 'Opendaylight',
            name: 'OpenDaylight (Experimental)',
            state: nspMap.Opendaylight ? nspMap.Opendaylight.state: 'Disabled'
        }];

        $(window).trigger('cloudStack.system.serviceProviders.makeHarcodedArray', {
            nspHardcodingArray: nspHardcodingArray,
            selectedZoneObj: selectedZoneObj,
            selectedPhysicalNetworkObj: selectedPhysicalNetworkObj
        });

        if (selectedZoneObj.networktype == "Basic") {
            nspHardcodingArray.push({
                id: 'securityGroups',
                name: 'Security Groups',
                state: nspMap.securityGroups ? nspMap.securityGroups.state: 'Disabled'
            });
        } else if (selectedZoneObj.networktype == "Advanced") {
            nspHardcodingArray.push({
                id: 'InternalLbVm',
                name: 'Internal LB VM',
                state: nspMap.InternalLbVm ? nspMap.InternalLbVm.state: 'Disabled'
            });

            nspHardcodingArray.push({
                id: 'vpcVirtualRouter',
                name: 'VPC Virtual Router',
                state: nspMap.vpcVirtualRouter ? nspMap.vpcVirtualRouter.state: 'Disabled'
            });
            nspHardcodingArray.push({
                id: 'f5',
                name: 'F5',
                state: nspMap.f5 ? nspMap.f5.state: 'Disabled'
            });
            nspHardcodingArray.push({
                id: 'srx',
                name: 'SRX',
                state: nspMap.srx ? nspMap.srx.state: 'Disabled'
            });
            nspHardcodingArray.push({
                id: 'pa',
                name: 'Palo Alto',
                state: nspMap.pa ? nspMap.pa.state: 'Disabled'
            });
            nspHardcodingArray.push({
                id: 'GloboDns',
                name: 'GloboDNS',
                state: nspMap.GloboDns ? nspMap.GloboDns.state : 'Disabled'
            });
            nspHardcodingArray.push({
                id: "ConfigDrive",
                name: "ConfigDrive",
                state: nspMap.ConfigDrive ? nspMap.ConfigDrive.state : 'Disabled'
            });

            //CLOUDSTACK-6840: OVS refers to SDN provider. However, we are not supporting SDN in this release.
            /*
            nspHardcodingArray.push({
                id: 'Ovs',
                name: 'Ovs',
                state: nspMap.Ovs ? nspMap.Ovs.state: 'Disabled'
            });
            */
        }
    };

    cloudStack.actionFilter.physicalNetwork = function (args) {
        var state = args.context.item.state;

        if (state != 'Destroyed') {
            return[ 'remove'];
        }

        return[];
    };

    function addExtraPropertiesToGroupbyObjects(groupbyObjs, groupbyId) {
        for (var i = 0; i < groupbyObjs.length; i++) {
            addExtraPropertiesToGroupbyObject(groupbyObjs[i], groupbyId);
        }
    }

    function addExtraPropertiesToGroupbyObject(groupbyObj, groupbyId) {
        var currentPage = 1;

        var listRoutersData = {
            listAll: true,
            pagesize: pageSize //global variable
        };
        listRoutersData[groupbyId] = groupbyObj.id;

        $.ajax({
            url: createURL('listRouters'),
            data: $.extend({
            },
            listRoutersData, {
                page: currentPage
            }),
            async: false,
            success: function(json) {
                if (json.listroutersresponse.count != undefined) {
                    var routerCountFromAllPages = json.listroutersresponse.count;
                    var routerCountFromFirstPageToCurrentPage = json.listroutersresponse.router.length;
                    var routerRequiresUpgrade = 0;

                    var items = json.listroutersresponse.router;
                    for (var k = 0; k < items.length; k++) {
                        if (items[k].requiresupgrade) {
                            routerRequiresUpgrade++;
                        }
                    }

                    $.ajax({
                        url: createURL('listRouters'),
                        data: $.extend({}, listRoutersData, {
                            page: currentPage,
                            projectid: -1
                        }),
                        async: false,
                        success: function(json) {
                            if (json.listroutersresponse.count != undefined) {
                                routerCountFromAllPages += json.listroutersresponse.count;
                                groupbyObj.routerCount = routerCountFromAllPages;

                                routerCountFromFirstPageToCurrentPage += json.listroutersresponse.router.length;

                                var items = json.listroutersresponse.router;
                                for (var k = 0; k < items.length; k++) {
                                    if (items[k].requiresupgrade) {
                                        routerRequiresUpgrade++;
                                    }
                                }
                            } else {
                                groupbyObj.routerCount = routerCountFromAllPages;
                            }
                        }
                    });

                    var callListApiWithPage = function() {
                        $.ajax({
                            url: createURL('listRouters'),
                            async: false,
                            data: $.extend({}, listRoutersData, {
                                page: currentPage
                            }),
                            success: function(json) {
                                routerCountFromFirstPageToCurrentPage += json.listroutersresponse.router.length;
                                var items = json.listroutersresponse.router;
                                for (var k = 0; k < items.length; k++) {
                                    if (items[k].requiresupgrade) {
                                        routerRequiresUpgrade++;
                                    }
                                }

                                $.ajax({
                                    url: createURL('listRouters'),
                                    async: false,
                                    data: $.extend({}, listRoutersData, {
                                        page: currentPage,
                                        projectid: -1
                                    }),
                                    success: function(json) {
                                        if (json.listroutersresponse.count != undefined) {
                                            routerCountFromAllPages += json.listroutersresponse.count;
                                            groupbyObj.routerCount = routerCountFromAllPages;

                                            routerCountFromFirstPageToCurrentPage += json.listroutersresponse.router.length;

                                            var items = json.listroutersresponse.router;
                                            for (var k = 0; k < items.length; k++) {
                                                if (items[k].requiresupgrade) {
                                                    routerRequiresUpgrade++;
                                                }
                                            }
                                        } else {
                                            groupbyObj.routerCount = routerCountFromAllPages;
                                        }
                                    }
                                });

                                if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                                    currentPage++;
                                    callListApiWithPage();
                                }
                            }
                        });
                    }

                    if (routerCountFromFirstPageToCurrentPage < routerCountFromAllPages) {
                        currentPage++;
                        callListApiWithPage();
                    }

                    groupbyObj.routerRequiresUpgrade = routerRequiresUpgrade;
                    groupbyObj.numberOfRouterRequiresUpgrade = routerRequiresUpgrade;
                } else {
                    groupbyObj.routerCount = 0;
                    groupbyObj.routerRequiresUpgrade = 0;
                    groupbyObj.numberOfRouterRequiresUpgrade = 0;
                }
            }
        });
    }
})($, cloudStack);