mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
1462 lines
60 KiB
JavaScript
1462 lines
60 KiB
JavaScript
// 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.
|
|
var g_mySession = null;
|
|
var g_sessionKey = null;
|
|
var g_role = null; // roles - root, domain-admin, ro-admin, user
|
|
var g_username = null;
|
|
var g_account = null;
|
|
var g_domainid = null;
|
|
var g_loginCmdText = null;
|
|
var g_enableLogging = false;
|
|
var g_timezoneoffset = null;
|
|
var g_timezone = null;
|
|
var g_supportELB = null;
|
|
var g_KVMsnapshotenabled = null;
|
|
var g_regionsecondaryenabled = null;
|
|
var g_userPublicTemplateEnabled = "true";
|
|
var g_cloudstackversion = null;
|
|
var g_queryAsyncJobResultInterval = 3000;
|
|
|
|
//keyboard keycode
|
|
var keycode_Enter = 13;
|
|
|
|
//XMLHttpResponse.status
|
|
var ERROR_ACCESS_DENIED_DUE_TO_UNAUTHORIZED = 401;
|
|
var ERROR_INTERNET_NAME_NOT_RESOLVED = 12007;
|
|
var ERROR_INTERNET_CANNOT_CONNECT = 12029;
|
|
var ERROR_VMOPS_ACCOUNT_ERROR = 531;
|
|
|
|
// Default password is MD5 hashed. Set the following variable to false to disable this.
|
|
var md5Hashed = false;
|
|
var md5HashedLogin = false;
|
|
|
|
//page size for API call (e.g."listXXXXXXX&pagesize=N" )
|
|
var pageSize = 20;
|
|
|
|
var rootAccountId = 1;
|
|
|
|
//async action
|
|
var pollAsyncJobResult = function(args) {
|
|
$.ajax({
|
|
url: createURL("queryAsyncJobResult&jobId=" + args._custom.jobId),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var result = json.queryasyncjobresultresponse;
|
|
if (result.jobstatus == 0) {
|
|
return; //Job has not completed
|
|
} else {
|
|
if (result.jobstatus == 1) { // Succeeded
|
|
if (args._custom.getUpdatedItem != null && args._custom.getActionFilter != null) {
|
|
args.complete({
|
|
data: args._custom.getUpdatedItem(json),
|
|
actionFilter: args._custom.getActionFilter()
|
|
});
|
|
} else if (args._custom.getUpdatedItem != null && args._custom.getActionFilter == null) {
|
|
args.complete({
|
|
data: args._custom.getUpdatedItem(json)
|
|
});
|
|
} else {
|
|
args.complete({
|
|
data: json.queryasyncjobresultresponse.jobresult
|
|
});
|
|
}
|
|
|
|
if (args._custom.fullRefreshAfterComplete == true) {
|
|
setTimeout(function() {
|
|
$(window).trigger('cloudStack.fullRefresh');
|
|
}, 500);
|
|
}
|
|
|
|
if (args._custom.onComplete) {
|
|
args._custom.onComplete(json, args._custom);
|
|
}
|
|
} else if (result.jobstatus == 2) { // Failed
|
|
var msg = (result.jobresult.errortext == null) ? "" : result.jobresult.errortext;
|
|
if (args._custom.getUpdatedItemWhenAsyncJobFails != null && args._custom.getActionFilter != null) {
|
|
args.error({
|
|
message: msg,
|
|
updatedData: args._custom.getUpdatedItemWhenAsyncJobFails(),
|
|
actionFilter: args._custom.getActionFilter()
|
|
});
|
|
} else if (args._custom.getUpdatedItemWhenAsyncJobFails != null && args._custom.getActionFilter == null) {
|
|
args.error({
|
|
message: msg,
|
|
updatedData: args._custom.getUpdatedItemWhenAsyncJobFails()
|
|
});
|
|
} else {
|
|
args.error({
|
|
message: msg
|
|
});
|
|
}
|
|
}
|
|
}
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
args.error();
|
|
}
|
|
});
|
|
}
|
|
|
|
//API calls
|
|
|
|
function createURL(apiName, options) {
|
|
if (!options) options = {};
|
|
var urlString = clientApiUrl + "?" + "command=" + apiName + "&response=json&sessionkey=" + g_sessionKey;
|
|
|
|
if (cloudStack.context && cloudStack.context.projects && !options.ignoreProject) {
|
|
urlString = urlString + '&projectid=' + cloudStack.context.projects[0].id;
|
|
}
|
|
|
|
return urlString;
|
|
}
|
|
|
|
function todb(val) {
|
|
return encodeURIComponent(val);
|
|
}
|
|
|
|
//LB provider map
|
|
var lbProviderMap = {
|
|
"publicLb": {
|
|
"non-vpc": ["VirtualRouter", "Netscaler", "F5"],
|
|
"vpc": ["VpcVirtualRouter", "Netscaler"]
|
|
},
|
|
"internalLb": {
|
|
"non-vpc": [],
|
|
"vpc": ["InternalLbVm"]
|
|
}
|
|
};
|
|
|
|
//Add Guest Network in Advanced zone (for root-admin only)
|
|
var addGuestNetworkDialog = {
|
|
zoneObjs: [],
|
|
physicalNetworkObjs: [],
|
|
networkOfferingObjs: [],
|
|
def: {
|
|
label: 'label.add.guest.network',
|
|
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.add.guest.network';
|
|
}
|
|
},
|
|
|
|
preFilter: function(args) {
|
|
if (isAdmin())
|
|
return true;
|
|
else
|
|
return false;
|
|
},
|
|
|
|
createForm: {
|
|
title: 'label.add.guest.network', //Add Shared Network in advanced zone
|
|
|
|
preFilter: function(args) {
|
|
if ('zones' in args.context) { //Infrastructure menu > zone detail > guest traffic type > network tab (only shown in advanced zone) > add guest network dialog
|
|
args.$form.find('.form-item[rel=zoneId]').hide();
|
|
args.$form.find('.form-item[rel=physicalNetworkId]').hide();
|
|
} else { //Network menu > guest network section > add guest network dialog
|
|
args.$form.find('.form-item[rel=zoneId]').css('display', 'inline-block');
|
|
args.$form.find('.form-item[rel=physicalNetworkId]').css('display', 'inline-block');
|
|
}
|
|
},
|
|
|
|
fields: {
|
|
name: {
|
|
docID: 'helpGuestNetworkZoneName',
|
|
label: 'label.name',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
description: {
|
|
label: 'label.description',
|
|
docID: 'helpGuestNetworkZoneDescription',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
|
|
zoneId: {
|
|
label: 'label.zone',
|
|
validation: {
|
|
required: true
|
|
},
|
|
docID: 'helpGuestNetworkZone',
|
|
select: function(args) {
|
|
if ('zones' in args.context) { //Infrastructure menu > zone detail > guest traffic type > network tab (only shown in advanced zone) > add guest network dialog
|
|
addGuestNetworkDialog.zoneObjs = args.context.zones; //i.e. only one zone entry
|
|
} else { //Network menu > guest network section > add guest network dialog
|
|
$.ajax({
|
|
url: createURL('listZones'),
|
|
async: false,
|
|
success: function(json) {
|
|
addGuestNetworkDialog.zoneObjs = []; //reset
|
|
var items = json.listzonesresponse.zone;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
if (items[i].networktype == 'Advanced') {
|
|
addGuestNetworkDialog.zoneObjs.push(items[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: $.map(addGuestNetworkDialog.zoneObjs, function(zone) {
|
|
return {
|
|
id: zone.id,
|
|
description: zone.name
|
|
};
|
|
})
|
|
});
|
|
},
|
|
isHidden: true
|
|
},
|
|
|
|
physicalNetworkId: {
|
|
label: 'label.physical.network',
|
|
dependsOn: 'zoneId',
|
|
select: function(args) {
|
|
if ('physicalNetworks' in args.context) {
|
|
addGuestNetworkDialog.physicalNetworkObjs = args.context.physicalNetworks;
|
|
} else {
|
|
var selectedZoneId = args.$form.find('.form-item[rel=zoneId]').find('select').val();
|
|
$.ajax({
|
|
url: createURL('listPhysicalNetworks'),
|
|
data: {
|
|
zoneid: selectedZoneId
|
|
},
|
|
async: false,
|
|
success: function(json) {
|
|
addGuestNetworkDialog.physicalNetworkObjs = json.listphysicalnetworksresponse.physicalnetwork;
|
|
}
|
|
});
|
|
}
|
|
var items = [];
|
|
if (addGuestNetworkDialog.physicalNetworkObjs != null) {
|
|
for (var i = 0; i < addGuestNetworkDialog.physicalNetworkObjs.length; i++) {
|
|
items.push({
|
|
id: addGuestNetworkDialog.physicalNetworkObjs[i].id,
|
|
description: addGuestNetworkDialog.physicalNetworkObjs[i].name
|
|
});
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
},
|
|
isHidden: true
|
|
},
|
|
|
|
vlanId: {
|
|
label: 'label.vlan.id',
|
|
docID: 'helpGuestNetworkZoneVLANID'
|
|
},
|
|
isolatedpvlanId: {
|
|
label: 'Secondary Isolated VLAN ID'
|
|
},
|
|
|
|
scope: {
|
|
label: 'label.scope',
|
|
docID: 'helpGuestNetworkZoneScope',
|
|
select: function(args) {
|
|
var selectedZoneId = args.$form.find('.form-item[rel=zoneId]').find('select').val();
|
|
var selectedZoneObj = {};
|
|
if (addGuestNetworkDialog.zoneObjs != null && selectedZoneId != "") {
|
|
for (var i = 0; i < addGuestNetworkDialog.zoneObjs.length; i++) {
|
|
if (addGuestNetworkDialog.zoneObjs[i].id == selectedZoneId) {
|
|
selectedZoneObj = addGuestNetworkDialog.zoneObjs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var array1 = [];
|
|
if (selectedZoneObj.networktype == "Advanced" && selectedZoneObj.securitygroupsenabled == true) {
|
|
array1.push({
|
|
id: 'zone-wide',
|
|
description: 'All'
|
|
});
|
|
} else {
|
|
array1.push({
|
|
id: 'zone-wide',
|
|
description: 'All'
|
|
});
|
|
array1.push({
|
|
id: 'domain-specific',
|
|
description: 'Domain'
|
|
});
|
|
array1.push({
|
|
id: 'account-specific',
|
|
description: 'Account'
|
|
});
|
|
array1.push({
|
|
id: 'project-specific',
|
|
description: 'Project'
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: array1
|
|
});
|
|
|
|
args.$select.change(function() {
|
|
var $form = $(this).closest('form');
|
|
if ($(this).val() == "zone-wide") {
|
|
$form.find('.form-item[rel=domainId]').hide();
|
|
$form.find('.form-item[rel=subdomainaccess]').hide();
|
|
$form.find('.form-item[rel=account]').hide();
|
|
$form.find('.form-item[rel=projectId]').hide();
|
|
} else if ($(this).val() == "domain-specific") {
|
|
$form.find('.form-item[rel=domainId]').css('display', 'inline-block');
|
|
$form.find('.form-item[rel=subdomainaccess]').css('display', 'inline-block');
|
|
$form.find('.form-item[rel=account]').hide();
|
|
$form.find('.form-item[rel=projectId]').hide();
|
|
} else if ($(this).val() == "account-specific") {
|
|
$form.find('.form-item[rel=domainId]').css('display', 'inline-block');
|
|
$form.find('.form-item[rel=subdomainaccess]').hide();
|
|
$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=subdomainaccess]').hide();
|
|
$form.find('.form-item[rel=account]').hide();
|
|
$form.find('.form-item[rel=projectId]').css('display', 'inline-block');
|
|
}
|
|
});
|
|
}
|
|
},
|
|
domainId: {
|
|
label: 'label.domain',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
var items = [];
|
|
var selectedZoneId = args.$form.find('.form-item[rel=zoneId]').find('select').val();
|
|
var selectedZoneObj = {};
|
|
if (addGuestNetworkDialog.zoneObjs != null && selectedZoneId != "") {
|
|
for (var i = 0; i < addGuestNetworkDialog.zoneObjs.length; i++) {
|
|
if (addGuestNetworkDialog.zoneObjs[i].id == selectedZoneId) {
|
|
selectedZoneObj = addGuestNetworkDialog.zoneObjs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (selectedZoneObj.domainid != null) { //list only domains under selectedZoneObj.domainid
|
|
$.ajax({
|
|
url: createURL("listDomainChildren&id=" + selectedZoneObj.domainid + "&isrecursive=true"),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var domainObjs = json.listdomainchildrenresponse.domain;
|
|
$(domainObjs).each(function() {
|
|
items.push({
|
|
id: this.id,
|
|
description: this.path
|
|
});
|
|
});
|
|
}
|
|
});
|
|
$.ajax({
|
|
url: createURL("listDomains&id=" + selectedZoneObj.domainid),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var domainObjs = json.listdomainsresponse.domain;
|
|
$(domainObjs).each(function() {
|
|
items.push({
|
|
id: this.id,
|
|
description: this.path
|
|
});
|
|
});
|
|
}
|
|
});
|
|
} else { //list all domains
|
|
$.ajax({
|
|
url: createURL("listDomains&listAll=true"),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var domainObjs = json.listdomainsresponse.domain;
|
|
$(domainObjs).each(function() {
|
|
items.push({
|
|
id: this.id,
|
|
description: this.path
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
},
|
|
subdomainaccess: {
|
|
label: 'label.subdomain.access',
|
|
isBoolean: true,
|
|
isHidden: true,
|
|
},
|
|
account: {
|
|
label: 'label.account'
|
|
},
|
|
|
|
projectId: {
|
|
label: 'label.project',
|
|
validation: {
|
|
required: true
|
|
},
|
|
select: function(args) {
|
|
var items = [];
|
|
$.ajax({
|
|
url: createURL("listProjects&listAll=true"),
|
|
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
|
|
});
|
|
}
|
|
},
|
|
|
|
networkOfferingId: {
|
|
label: 'label.network.offering',
|
|
docID: 'helpGuestNetworkZoneNetworkOffering',
|
|
dependsOn: ['zoneId', 'scope'],
|
|
select: function(args) {
|
|
var data = {
|
|
state: 'Enabled',
|
|
zoneid: args.$form.find('.form-item[rel=zoneId]').find('select').val()
|
|
};
|
|
|
|
var selectedPhysicalNetworkObj = [];
|
|
var selectedPhysicalNetworkId = args.$form.find('.form-item[rel=physicalNetworkId]').find('select').val();
|
|
if (addGuestNetworkDialog.physicalNetworkObjs != null) {
|
|
for (var i = 0; i < addGuestNetworkDialog.physicalNetworkObjs.length; i++) {
|
|
if (addGuestNetworkDialog.physicalNetworkObjs[i].id == selectedPhysicalNetworkId) {
|
|
selectedPhysicalNetworkObj = addGuestNetworkDialog.physicalNetworkObjs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (selectedPhysicalNetworkObj.tags != null && selectedPhysicalNetworkObj.tags.length > 0) {
|
|
$.extend(data, {
|
|
tags: selectedPhysicalNetworkObj.tags
|
|
});
|
|
}
|
|
|
|
//Network tab in Guest Traffic Type in Infrastructure menu is only available when it's under Advanced zone.
|
|
//zone dropdown in add guest network dialog includes only Advanced zones.
|
|
if (args.scope == "zone-wide" || args.scope == "domain-specific") {
|
|
$.extend(data, {
|
|
guestiptype: 'Shared'
|
|
});
|
|
}
|
|
|
|
var items = [];
|
|
$.ajax({
|
|
url: createURL('listNetworkOfferings'),
|
|
data: data,
|
|
async: false,
|
|
success: function(json) {
|
|
addGuestNetworkDialog.networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering;
|
|
if (addGuestNetworkDialog.networkOfferingObjs != null && addGuestNetworkDialog.networkOfferingObjs.length > 0) {
|
|
var selectedZoneId = args.$form.find('.form-item[rel=zoneId]').find('select').val();
|
|
var selectedZoneObj = {};
|
|
if (addGuestNetworkDialog.zoneObjs != null && selectedZoneId != "") {
|
|
for (var i = 0; i < addGuestNetworkDialog.zoneObjs.length; i++) {
|
|
if (addGuestNetworkDialog.zoneObjs[i].id == selectedZoneId) {
|
|
selectedZoneObj = addGuestNetworkDialog.zoneObjs[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (var i = 0; i < addGuestNetworkDialog.networkOfferingObjs.length; i++) {
|
|
//for zone-wide network in Advanced SG-enabled zone, list only SG network offerings
|
|
if (selectedZoneObj.networktype == 'Advanced' && selectedZoneObj.securitygroupsenabled == true) {
|
|
if (args.scope == "zone-wide") {
|
|
var includingSecurityGroup = false;
|
|
var serviceObjArray = addGuestNetworkDialog.networkOfferingObjs[i].service;
|
|
for (var k = 0; k < serviceObjArray.length; k++) {
|
|
if (serviceObjArray[k].name == "SecurityGroup") {
|
|
includingSecurityGroup = true;
|
|
break;
|
|
}
|
|
}
|
|
if (includingSecurityGroup == false)
|
|
continue; //skip to next network offering
|
|
}
|
|
}
|
|
items.push({
|
|
id: addGuestNetworkDialog.networkOfferingObjs[i].id,
|
|
description: addGuestNetworkDialog.networkOfferingObjs[i].displaytext
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
|
|
args.$select.change(function() {
|
|
var $form = $(this).closest("form");
|
|
var selectedNetworkOfferingId = $(this).val();
|
|
$(addGuestNetworkDialog.networkOfferingObjs).each(function() {
|
|
if (this.id == selectedNetworkOfferingId) {
|
|
if (this.specifyvlan == false) {
|
|
$form.find('.form-item[rel=vlanId]').hide();
|
|
cloudStack.dialog.createFormField.validation.required.remove($form.find('.form-item[rel=vlanId]')); //make vlanId optional
|
|
|
|
$form.find('.form-item[rel=isolatedpvlanId]').hide();
|
|
} else {
|
|
$form.find('.form-item[rel=vlanId]').css('display', 'inline-block');
|
|
cloudStack.dialog.createFormField.validation.required.add($form.find('.form-item[rel=vlanId]')); //make vlanId required
|
|
|
|
$form.find('.form-item[rel=isolatedpvlanId]').css('display', 'inline-block');
|
|
}
|
|
return false; //break each loop
|
|
}
|
|
});
|
|
});
|
|
}
|
|
},
|
|
|
|
//IPv4 (begin)
|
|
ip4gateway: {
|
|
label: 'IPv4 Gateway',
|
|
docID: 'helpGuestNetworkZoneGateway'
|
|
},
|
|
ip4Netmask: {
|
|
label: 'IPv4 Netmask',
|
|
docID: 'helpGuestNetworkZoneNetmask'
|
|
},
|
|
startipv4: {
|
|
label: 'IPv4 Start IP',
|
|
docID: 'helpGuestNetworkZoneStartIP'
|
|
},
|
|
endipv4: {
|
|
label: 'IPv4 End IP',
|
|
docID: 'helpGuestNetworkZoneEndIP'
|
|
},
|
|
//IPv4 (end)
|
|
|
|
//IPv6 (begin)
|
|
ip6gateway: {
|
|
label: 'IPv6 Gateway',
|
|
docID: 'helpGuestNetworkZoneGateway'
|
|
},
|
|
ip6cidr: {
|
|
label: 'IPv6 CIDR'
|
|
},
|
|
startipv6: {
|
|
label: 'IPv6 Start IP',
|
|
docID: 'helpGuestNetworkZoneStartIP'
|
|
},
|
|
endipv6: {
|
|
label: 'IPv6 End IP',
|
|
docID: 'helpGuestNetworkZoneEndIP'
|
|
},
|
|
//IPv6 (end)
|
|
|
|
networkdomain: {
|
|
label: 'label.network.domain',
|
|
docID: 'helpGuestNetworkZoneNetworkDomain'
|
|
}
|
|
}
|
|
},
|
|
|
|
action: function(args) { //Add guest network in advanced zone
|
|
if (
|
|
((args.data.ip4gateway.length == 0) && (args.data.ip4Netmask.length == 0) && (args.data.startipv4.length == 0) && (args.data.endipv4.length == 0)) &&
|
|
((args.data.ip6gateway.length == 0) && (args.data.ip6cidr.length == 0) && (args.data.startipv6.length == 0) && (args.data.endipv6.length == 0))
|
|
) {
|
|
args.response.error("Either IPv4 fields or IPv6 fields need to be filled when adding a guest network");
|
|
return;
|
|
}
|
|
|
|
var $form = args.$form;
|
|
|
|
var array1 = [];
|
|
array1.push("&zoneId=" + args.data.zoneId);
|
|
array1.push("&networkOfferingId=" + args.data.networkOfferingId);
|
|
|
|
//Pass physical network ID to createNetwork API only when network offering's guestiptype is Shared.
|
|
var selectedNetworkOfferingObj;
|
|
if (addGuestNetworkDialog.networkOfferingObjs != null) {
|
|
for (var i = 0; i < addGuestNetworkDialog.networkOfferingObjs.length; i++) {
|
|
if (addGuestNetworkDialog.networkOfferingObjs[i].id == args.data.networkOfferingId) {
|
|
selectedNetworkOfferingObj = addGuestNetworkDialog.networkOfferingObjs[i]
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selectedNetworkOfferingObj.guestiptype == "Shared")
|
|
array1.push("&physicalnetworkid=" + args.data.physicalNetworkId);
|
|
|
|
array1.push("&name=" + todb(args.data.name));
|
|
array1.push("&displayText=" + todb(args.data.description));
|
|
|
|
if (($form.find('.form-item[rel=vlanId]').css("display") != "none") && (args.data.vlanId != null && args.data.vlanId.length > 0))
|
|
array1.push("&vlan=" + todb(args.data.vlanId));
|
|
|
|
if (($form.find('.form-item[rel=isolatedpvlanId]').css("display") != "none") && (args.data.isolatedpvlanId != null && args.data.isolatedpvlanId.length > 0))
|
|
array1.push("&isolatedpvlan=" + todb(args.data.isolatedpvlanId));
|
|
|
|
if ($form.find('.form-item[rel=domainId]').css("display") != "none") {
|
|
array1.push("&domainId=" + args.data.domainId);
|
|
|
|
if ($form.find('.form-item[rel=account]').css("display") != "none") { //account-specific
|
|
array1.push("&account=" + args.data.account);
|
|
array1.push("&acltype=account");
|
|
} else if ($form.find('.form-item[rel=projectId]').css("display") != "none") { //project-specific
|
|
array1.push("&projectid=" + args.data.projectId);
|
|
array1.push("&acltype=account");
|
|
} else { //domain-specific
|
|
array1.push("&acltype=domain");
|
|
|
|
if ($form.find('.form-item[rel=subdomainaccess]:visible input:checked').size())
|
|
array1.push("&subdomainaccess=true");
|
|
else
|
|
array1.push("&subdomainaccess=false");
|
|
}
|
|
} else { //zone-wide
|
|
array1.push("&acltype=domain"); //server-side will make it Root domain (i.e. domainid=1)
|
|
}
|
|
|
|
//IPv4 (begin)
|
|
if (args.data.ip4gateway != null && args.data.ip4gateway.length > 0)
|
|
array1.push("&gateway=" + args.data.ip4gateway);
|
|
if (args.data.ip4Netmask != null && args.data.ip4Netmask.length > 0)
|
|
array1.push("&netmask=" + args.data.ip4Netmask);
|
|
if (($form.find('.form-item[rel=startipv4]').css("display") != "none") && (args.data.startipv4 != null && args.data.startipv4.length > 0))
|
|
array1.push("&startip=" + args.data.startipv4);
|
|
if (($form.find('.form-item[rel=endipv4]').css("display") != "none") && (args.data.endipv4 != null && args.data.endipv4.length > 0))
|
|
array1.push("&endip=" + args.data.endipv4);
|
|
//IPv4 (end)
|
|
|
|
//IPv6 (begin)
|
|
if (args.data.ip6gateway != null && args.data.ip6gateway.length > 0)
|
|
array1.push("&ip6gateway=" + args.data.ip6gateway);
|
|
if (args.data.ip6cidr != null && args.data.ip6cidr.length > 0)
|
|
array1.push("&ip6cidr=" + args.data.ip6cidr);
|
|
if (($form.find('.form-item[rel=startipv6]').css("display") != "none") && (args.data.startipv6 != null && args.data.startipv6.length > 0))
|
|
array1.push("&startipv6=" + args.data.startipv6);
|
|
if (($form.find('.form-item[rel=endipv6]').css("display") != "none") && (args.data.endipv6 != null && args.data.endipv6.length > 0))
|
|
array1.push("&endipv6=" + args.data.endipv6);
|
|
//IPv6 (end)
|
|
|
|
if (args.data.networkdomain != null && args.data.networkdomain.length > 0)
|
|
array1.push("&networkdomain=" + todb(args.data.networkdomain));
|
|
|
|
$.ajax({
|
|
url: createURL("createNetwork" + array1.join("")),
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var item = json.createnetworkresponse.network;
|
|
args.response.success({
|
|
data: item
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: function(args) {
|
|
args.complete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Role Functions
|
|
|
|
function isAdmin() {
|
|
return (g_role == 1);
|
|
}
|
|
|
|
function isDomainAdmin() {
|
|
return (g_role == 2);
|
|
}
|
|
|
|
function isUser() {
|
|
return (g_role == 0);
|
|
}
|
|
|
|
function isSelfOrChildDomainUser(username, useraccounttype, userdomainid, iscallerchilddomain) {
|
|
if (username == g_username) { //is self
|
|
return true;
|
|
} else if (isDomainAdmin() && iscallerchilddomain && (useraccounttype == 0)) { //domain admin to user
|
|
return true;
|
|
} else if (isDomainAdmin() && iscallerchilddomain && (userdomainid != g_domainid)) { //domain admin to subdomain admin and user
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// FUNCTION: Handles AJAX error callbacks. You can pass in an optional function to
|
|
// handle errors that are not already handled by this method.
|
|
|
|
function handleError(XMLHttpResponse, handleErrorCallback) {
|
|
// User Not authenticated
|
|
if (XMLHttpResponse.status == ERROR_ACCESS_DENIED_DUE_TO_UNAUTHORIZED) {
|
|
$("#dialog_session_expired").dialog("open");
|
|
} else if (XMLHttpResponse.status == ERROR_INTERNET_NAME_NOT_RESOLVED) {
|
|
$("#dialog_error_internet_not_resolved").dialog("open");
|
|
} else if (XMLHttpResponse.status == ERROR_INTERNET_CANNOT_CONNECT) {
|
|
$("#dialog_error_management_server_not_accessible").dialog("open");
|
|
} else if (XMLHttpResponse.status == ERROR_VMOPS_ACCOUNT_ERROR && handleErrorCallback != undefined) {
|
|
handleErrorCallback();
|
|
} else if (handleErrorCallback != undefined) {
|
|
handleErrorCallback();
|
|
} else {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
$("#dialog_error").text(_s(errorMsg)).dialog("open");
|
|
}
|
|
}
|
|
|
|
function parseXMLHttpResponse(XMLHttpResponse) {
|
|
if (isValidJsonString(XMLHttpResponse.responseText) == false) {
|
|
return "";
|
|
}
|
|
|
|
//var json = jQuery.parseJSON(XMLHttpResponse.responseText);
|
|
var json = JSON.parse(XMLHttpResponse.responseText);
|
|
if (json != null) {
|
|
var property;
|
|
for (property in json) {
|
|
var errorObj = json[property];
|
|
if (errorObj.errorcode == 401 && errorObj.errortext == "unable to verify user credentials and/or request signature")
|
|
return _l('label.session.expired');
|
|
else
|
|
return _s(errorObj.errortext);
|
|
}
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
function isValidJsonString(str) {
|
|
try {
|
|
JSON.parse(str);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
cloudStack.validate = {
|
|
vmHostName: function(args) {
|
|
// 1 ~ 63 characters long
|
|
// ASCII letters 'a' through 'z', 'A' through 'Z', digits '0' through '9', hyphen ('-')
|
|
// must start with a letter
|
|
// must end with a letter or a digit (must not end with a hyphen)
|
|
var regexp = /^[a-zA-Z]{1}[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]{0,1}$/;
|
|
var b = regexp.test(args); //true or false
|
|
if (b == false)
|
|
cloudStack.dialog.notice({
|
|
message: 'message.validate.instance.name'
|
|
});
|
|
return b;
|
|
}
|
|
}
|
|
|
|
cloudStack.preFilter = {
|
|
createTemplate: function(args) {
|
|
if (isAdmin()) {
|
|
args.$form.find('.form-item[rel=isPublic]').css('display', 'inline-block');
|
|
args.$form.find('.form-item[rel=isFeatured]').css('display', 'inline-block');
|
|
args.$form.find('.form-item[rel=isrouting]').css('display', 'inline-block');
|
|
} else {
|
|
if (g_userPublicTemplateEnabled == "true") {
|
|
args.$form.find('.form-item[rel=isPublic]').css('display', 'inline-block');
|
|
} else {
|
|
args.$form.find('.form-item[rel=isPublic]').hide();
|
|
}
|
|
args.$form.find('.form-item[rel=isFeatured]').hide();
|
|
}
|
|
},
|
|
addLoadBalancerDevice: function(args) { //add netscaler device OR add F5 device
|
|
args.$form.find('.form-item[rel=dedicated]').bind('change', function() {
|
|
var $dedicated = args.$form.find('.form-item[rel=dedicated]');
|
|
var $capacity = args.$form.find('.form-item[rel=capacity]');
|
|
if ($dedicated.find('input[type=checkbox]:checked').length > 0) {
|
|
$capacity.hide();
|
|
$capacity.find('input[type=text]').val('1');
|
|
} else if ($dedicated.find('input[type=checkbox]:unchecked').length > 0) {
|
|
$capacity.css('display', 'inline-block');
|
|
$capacity.find('input[type=text]').val('');
|
|
}
|
|
});
|
|
args.$form.change();
|
|
}
|
|
}
|
|
|
|
cloudStack.actionFilter = {
|
|
guestNetwork: function(args) {
|
|
var jsonObj = args.context.item;
|
|
var allowedActions = [];
|
|
allowedActions.push('replaceacllist');
|
|
if (jsonObj.type == 'Isolated') {
|
|
allowedActions.push('edit'); //only Isolated network is allowed to upgrade to a different network offering (Shared network is not allowed to)
|
|
allowedActions.push('restart');
|
|
allowedActions.push('remove');
|
|
} else if (jsonObj.type == 'Shared') {
|
|
if (isAdmin()) {
|
|
allowedActions.push('restart');
|
|
allowedActions.push('remove');
|
|
}
|
|
}
|
|
return allowedActions;
|
|
}
|
|
}
|
|
|
|
var roleTypeUser = "0";
|
|
var roleTypeAdmin = "1";
|
|
var roleTypeDomainAdmin = "2";
|
|
|
|
cloudStack.converters = {
|
|
convertBytes: function(bytes) {
|
|
if (bytes < 1024 * 1024) {
|
|
return (bytes / 1024).toFixed(2) + " KB";
|
|
} else if (bytes < 1024 * 1024 * 1024) {
|
|
return (bytes / 1024 / 1024).toFixed(2) + " MB";
|
|
} else if (bytes < 1024 * 1024 * 1024 * 1024) {
|
|
return (bytes / 1024 / 1024 / 1024).toFixed(2) + " GB";
|
|
} else {
|
|
return (bytes / 1024 / 1024 / 1024 / 1024).toFixed(2) + " TB";
|
|
}
|
|
},
|
|
toLocalDate: function(UtcDate) {
|
|
var localDate = "";
|
|
if (UtcDate != null && UtcDate.length > 0) {
|
|
var disconnected = new Date();
|
|
disconnected.setISO8601(UtcDate);
|
|
|
|
if (g_timezoneoffset != null)
|
|
localDate = disconnected.getTimePlusTimezoneOffset(g_timezoneoffset);
|
|
else
|
|
localDate = disconnected.toUTCString();
|
|
// localDate = disconnected.getTimePlusTimezoneOffset(0);
|
|
}
|
|
return localDate;
|
|
},
|
|
toBooleanText: function(booleanValue) {
|
|
if (booleanValue == true)
|
|
return "Yes";
|
|
|
|
return "No";
|
|
},
|
|
convertHz: function(hz) {
|
|
if (hz == null)
|
|
return "";
|
|
|
|
if (hz < 1000) {
|
|
return hz + " MHz";
|
|
} else {
|
|
return (hz / 1000).toFixed(2) + " GHz";
|
|
}
|
|
},
|
|
toDayOfWeekDesp: function(dayOfWeek) {
|
|
if (dayOfWeek == "1")
|
|
return "Sunday";
|
|
else if (dayOfWeek == "2")
|
|
return "Monday";
|
|
else if (dayOfWeek == "3")
|
|
return "Tuesday";
|
|
else if (dayOfWeek == "4")
|
|
return "Wednesday";
|
|
else if (dayOfWeek == "5")
|
|
return "Thursday"
|
|
else if (dayOfWeek == "6")
|
|
return "Friday";
|
|
else if (dayOfWeek == "7")
|
|
return "Saturday";
|
|
},
|
|
toDayOfWeekDesp: function(dayOfWeek) {
|
|
if (dayOfWeek == "1")
|
|
return "Sunday";
|
|
else if (dayOfWeek == "2")
|
|
return "Monday";
|
|
else if (dayOfWeek == "3")
|
|
return "Tuesday";
|
|
else if (dayOfWeek == "4")
|
|
return "Wednesday";
|
|
else if (dayOfWeek == "5")
|
|
return "Thursday"
|
|
else if (dayOfWeek == "6")
|
|
return "Friday";
|
|
else if (dayOfWeek == "7")
|
|
return "Saturday";
|
|
},
|
|
toNetworkType: function(usevirtualnetwork) {
|
|
if (usevirtualnetwork == true || usevirtualnetwork == "true")
|
|
return "Public";
|
|
else
|
|
return "Direct";
|
|
},
|
|
toRole: function(type) {
|
|
if (type == roleTypeUser) {
|
|
return "User";
|
|
} else if (type == roleTypeAdmin) {
|
|
return "Admin";
|
|
} else if (type == roleTypeDomainAdmin) {
|
|
return "Domain-Admin";
|
|
}
|
|
},
|
|
toAlertType: function(alertCode) {
|
|
switch (alertCode) {
|
|
case 0:
|
|
return _l('label.memory');
|
|
case 1:
|
|
return _l('label.cpu');
|
|
case 2:
|
|
return _l('label.storage');
|
|
case 3:
|
|
return _l('label.primary.storage');
|
|
case 4:
|
|
return _l('label.public.ips');
|
|
case 5:
|
|
return _l('label.management.ips');
|
|
case 6:
|
|
return _l('label.secondary.storage');
|
|
case 7:
|
|
return _l('label.host');
|
|
case 9:
|
|
return _l('label.domain.router');
|
|
case 10:
|
|
return _l('label.console.proxy');
|
|
|
|
// These are old values -- can be removed in the future
|
|
case 8:
|
|
return "User VM";
|
|
case 11:
|
|
return "Routing Host";
|
|
case 12:
|
|
return "Storage";
|
|
case 13:
|
|
return "Usage Server";
|
|
case 14:
|
|
return "Management Server";
|
|
case 15:
|
|
return "Domain Router";
|
|
case 16:
|
|
return "Console Proxy";
|
|
case 17:
|
|
return "User VM";
|
|
case 18:
|
|
return "VLAN";
|
|
case 19:
|
|
return "Secondary Storage VM";
|
|
case 20:
|
|
return "Usage Server";
|
|
case 21:
|
|
return "Storage";
|
|
case 22:
|
|
return "Update Resource Count";
|
|
case 23:
|
|
return "Usage Sanity Result";
|
|
case 24:
|
|
return "Direct Attached Public IP";
|
|
case 25:
|
|
return "Local Storage";
|
|
case 26:
|
|
return "Resource Limit Exceeded";
|
|
}
|
|
},
|
|
|
|
toCapacityCountType: function(capacityCode) {
|
|
switch (capacityCode) {
|
|
case 0:
|
|
return _l('label.memory');
|
|
case 1:
|
|
return _l('label.cpu');
|
|
case 2:
|
|
return _l('label.storage');
|
|
case 3:
|
|
return _l('label.primary.storage');
|
|
case 4:
|
|
return _l('label.public.ips');
|
|
case 5:
|
|
return _l('label.management.ips');
|
|
case 6:
|
|
return _l('label.secondary.storage');
|
|
case 7:
|
|
return _l('label.vlan');
|
|
case 8:
|
|
return _l('label.direct.ips');
|
|
case 9:
|
|
return _l('label.local.storage');
|
|
case 10:
|
|
return "Routing Host";
|
|
case 11:
|
|
return "Storage";
|
|
case 12:
|
|
return "Usage Server";
|
|
case 13:
|
|
return "Management Server";
|
|
case 14:
|
|
return "Domain Router";
|
|
case 15:
|
|
return "Console Proxy";
|
|
case 16:
|
|
return "User VM";
|
|
case 17:
|
|
return "VLAN";
|
|
case 18:
|
|
return "Secondary Storage VM";
|
|
}
|
|
},
|
|
|
|
convertByType: function(alertCode, value) {
|
|
switch (alertCode) {
|
|
case 0:
|
|
return cloudStack.converters.convertBytes(value);
|
|
case 1:
|
|
return cloudStack.converters.convertHz(value);
|
|
case 2:
|
|
return cloudStack.converters.convertBytes(value);
|
|
case 3:
|
|
return cloudStack.converters.convertBytes(value);
|
|
case 6:
|
|
return cloudStack.converters.convertBytes(value);
|
|
case 9:
|
|
return cloudStack.converters.convertBytes(value);
|
|
case 11:
|
|
return cloudStack.converters.convertBytes(value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}
|
|
|
|
//data parameter passed to API call in listView
|
|
|
|
function listViewDataProvider(args, data) {
|
|
//search
|
|
if (args.filterBy != null) {
|
|
if (args.filterBy.advSearch != null && typeof(args.filterBy.advSearch) == "object") { //advanced search
|
|
for (var key in args.filterBy.advSearch) {
|
|
if (key == 'tagKey' && args.filterBy.advSearch[key].length > 0) {
|
|
$.extend(data, {
|
|
'tags[0].key': args.filterBy.advSearch[key]
|
|
});
|
|
} else if (key == 'tagValue' && args.filterBy.advSearch[key].length > 0) {
|
|
$.extend(data, {
|
|
'tags[0].value': args.filterBy.advSearch[key]
|
|
});
|
|
} else if (args.filterBy.advSearch[key] != null && args.filterBy.advSearch[key].length > 0) {
|
|
data[key] = args.filterBy.advSearch[key]; //do NOT use $.extend(data, { key: args.filterBy.advSearch[key] }); which will treat key variable as "key" string
|
|
}
|
|
}
|
|
} else if (args.filterBy.search != null && args.filterBy.search.by != null && args.filterBy.search.value != null) { //basic search
|
|
switch (args.filterBy.search.by) {
|
|
case "name":
|
|
if (args.filterBy.search.value.length > 0) {
|
|
$.extend(data, {
|
|
keyword: args.filterBy.search.value
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//pagination
|
|
$.extend(data, {
|
|
listAll: true,
|
|
page: args.page,
|
|
pagesize: pageSize
|
|
});
|
|
}
|
|
|
|
//used by infrastruct page and network page
|
|
var addExtraPropertiesToGuestNetworkObject = function(jsonObj) {
|
|
jsonObj.networkdomaintext = jsonObj.networkdomain;
|
|
jsonObj.networkofferingidText = jsonObj.networkofferingid;
|
|
|
|
if (jsonObj.acltype == "Domain") {
|
|
if (jsonObj.domainid == rootAccountId)
|
|
jsonObj.scope = "All";
|
|
else
|
|
jsonObj.scope = "Domain (" + jsonObj.domain + ")";
|
|
} else if (jsonObj.acltype == "Account") {
|
|
if (jsonObj.project != null)
|
|
jsonObj.scope = "Account (" + jsonObj.domain + ", " + jsonObj.project + ")";
|
|
else
|
|
jsonObj.scope = "Account (" + jsonObj.domain + ", " + jsonObj.account + ")";
|
|
}
|
|
|
|
if (jsonObj.vlan == null && jsonObj.broadcasturi != null) {
|
|
jsonObj.vlan = jsonObj.broadcasturi.replace("vlan://", "");
|
|
}
|
|
}
|
|
|
|
//find service object in network object
|
|
|
|
function ipFindNetworkServiceByName(pName, networkObj) {
|
|
if (networkObj == null)
|
|
return null;
|
|
if (networkObj.service != null) {
|
|
for (var i = 0; i < networkObj.service.length; i++) {
|
|
var networkServiceObj = networkObj.service[i];
|
|
if (networkServiceObj.name == pName)
|
|
return networkServiceObj;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
//find capability object in service object in network object
|
|
|
|
function ipFindCapabilityByName(pName, networkServiceObj) {
|
|
if (networkServiceObj == null)
|
|
return null;
|
|
if (networkServiceObj.capability != null) {
|
|
for (var i = 0; i < networkServiceObj.capability.length; i++) {
|
|
var capabilityObj = networkServiceObj.capability[i];
|
|
if (capabilityObj.name == pName)
|
|
return capabilityObj;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//compose URL for adding primary storage
|
|
|
|
function nfsURL(server, path) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "nfs://" + server + path;
|
|
else
|
|
url = server + path;
|
|
return url;
|
|
}
|
|
|
|
function presetupURL(server, path) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "presetup://" + server + path;
|
|
else
|
|
url = server + path;
|
|
return url;
|
|
}
|
|
|
|
function ocfs2URL(server, path) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "ocfs2://" + server + path;
|
|
else
|
|
url = server + path;
|
|
return url;
|
|
}
|
|
|
|
function SharedMountPointURL(server, path) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "SharedMountPoint://" + server + path;
|
|
else
|
|
url = server + path;
|
|
return url;
|
|
}
|
|
|
|
function rbdURL(monitor, pool, id, secret) {
|
|
var url;
|
|
|
|
/*
|
|
Replace the + and / symbols by - and _ to have URL-safe base64 going to the API
|
|
It's hacky, but otherwise we'll confuse java.net.URI which splits the incoming URI
|
|
*/
|
|
secret = secret.replace("+", "-");
|
|
secret = secret.replace("/", "_");
|
|
|
|
if (id != null && secret != null) {
|
|
monitor = id + ":" + secret + "@" + monitor;
|
|
}
|
|
|
|
if (pool.substring(0, 1) != "/")
|
|
pool = "/" + pool;
|
|
|
|
if (monitor.indexOf("://") == -1)
|
|
url = "rbd://" + monitor + pool;
|
|
else
|
|
url = monitor + pool;
|
|
|
|
return url;
|
|
}
|
|
|
|
function clvmURL(vgname) {
|
|
var url;
|
|
if (vgname.indexOf("://") == -1)
|
|
url = "clvm://localhost/" + vgname;
|
|
else
|
|
url = vgname;
|
|
return url;
|
|
}
|
|
|
|
function vmfsURL(server, path) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "vmfs://" + server + path;
|
|
else
|
|
url = server + path;
|
|
return url;
|
|
}
|
|
|
|
function iscsiURL(server, iqn, lun) {
|
|
var url;
|
|
if (server.indexOf("://") == -1)
|
|
url = "iscsi://" + server + iqn + "/" + lun;
|
|
else
|
|
url = server + iqn + "/" + lun;
|
|
return url;
|
|
}
|
|
|
|
|
|
//VM Instance
|
|
|
|
function getVmName(p_vmName, p_vmDisplayname) {
|
|
if (p_vmDisplayname == null)
|
|
return _s(p_vmName);
|
|
|
|
var vmName = null;
|
|
if (p_vmDisplayname != p_vmName) {
|
|
vmName = _s(p_vmName) + " (" + _s(p_vmDisplayname) + ")";
|
|
} else {
|
|
vmName = _s(p_vmName);
|
|
}
|
|
return vmName;
|
|
}
|
|
|
|
var timezoneMap = new Object();
|
|
timezoneMap['Etc/GMT+12'] = '[UTC-12:00] GMT-12:00';
|
|
timezoneMap['Etc/GMT+11'] = '[UTC-11:00] GMT-11:00';
|
|
timezoneMap['Pacific/Samoa'] = '[UTC-11:00] Samoa Standard Time';
|
|
timezoneMap['Pacific/Honolulu'] = '[UTC-10:00] Hawaii Standard Time';
|
|
timezoneMap['US/Alaska'] = '[UTC-09:00] Alaska Standard Time';
|
|
timezoneMap['America/Los_Angeles'] = '[UTC-08:00] Pacific Standard Time';
|
|
timezoneMap['Mexico/BajaNorte'] = '[UTC-08:00] Baja California';
|
|
timezoneMap['US/Arizona'] = '[UTC-07:00] Arizona';
|
|
timezoneMap['US/Mountain'] = '[UTC-07:00] Mountain Standard Time';
|
|
timezoneMap['America/Chihuahua'] = '[UTC-07:00] Chihuahua, La Paz';
|
|
timezoneMap['America/Chicago'] = '[UTC-06:00] Central Standard Time';
|
|
timezoneMap['America/Costa_Rica'] = '[UTC-06:00] Central America';
|
|
timezoneMap['America/Mexico_City'] = '[UTC-06:00] Mexico City, Monterrey';
|
|
timezoneMap['Canada/Saskatchewan'] = '[UTC-06:00] Saskatchewan';
|
|
timezoneMap['America/Bogota'] = '[UTC-05:00] Bogota, Lima';
|
|
timezoneMap['America/New_York'] = '[UTC-05:00] Eastern Standard Time';
|
|
timezoneMap['America/Caracas'] = '[UTC-04:00] Venezuela Time';
|
|
timezoneMap['America/Asuncion'] = '[UTC-04:00] Paraguay Time';
|
|
timezoneMap['America/Cuiaba'] = '[UTC-04:00] Amazon Time';
|
|
timezoneMap['America/Halifax'] = '[UTC-04:00] Atlantic Standard Time';
|
|
timezoneMap['America/La_Paz'] = '[UTC-04:00] Bolivia Time';
|
|
timezoneMap['America/Santiago'] = '[UTC-04:00] Chile Time';
|
|
timezoneMap['America/St_Johns'] = '[UTC-03:30] Newfoundland Standard Time';
|
|
timezoneMap['America/Araguaina'] = '[UTC-03:00] Brasilia Time';
|
|
timezoneMap['America/Argentina/Buenos_Aires'] = '[UTC-03:00] Argentine Time';
|
|
timezoneMap['America/Cayenne'] = '[UTC-03:00] French Guiana Time';
|
|
timezoneMap['America/Godthab'] = '[UTC-03:00] Greenland Time';
|
|
timezoneMap['America/Montevideo'] = '[UTC-03:00] Uruguay Time]';
|
|
timezoneMap['Etc/GMT+2'] = '[UTC-02:00] GMT-02:00';
|
|
timezoneMap['Atlantic/Azores'] = '[UTC-01:00] Azores Time';
|
|
timezoneMap['Atlantic/Cape_Verde'] = '[UTC-01:00] Cape Verde Time';
|
|
timezoneMap['Africa/Casablanca'] = '[UTC] Casablanca';
|
|
timezoneMap['Etc/UTC'] = '[UTC] Coordinated Universal Time';
|
|
timezoneMap['Atlantic/Reykjavik'] = '[UTC] Reykjavik';
|
|
timezoneMap['Europe/London'] = '[UTC] Western European Time';
|
|
timezoneMap['CET'] = '[UTC+01:00] Central European Time';
|
|
timezoneMap['Europe/Bucharest'] = '[UTC+02:00] Eastern European Time';
|
|
timezoneMap['Africa/Johannesburg'] = '[UTC+02:00] South Africa Standard Time';
|
|
timezoneMap['Asia/Beirut'] = '[UTC+02:00] Beirut';
|
|
timezoneMap['Africa/Cairo'] = '[UTC+02:00] Cairo';
|
|
timezoneMap['Asia/Jerusalem'] = '[UTC+02:00] Israel Standard Time';
|
|
timezoneMap['Europe/Minsk'] = '[UTC+02:00] Minsk';
|
|
timezoneMap['Europe/Moscow'] = '[UTC+03:00] Moscow Standard Time';
|
|
timezoneMap['Africa/Nairobi'] = '[UTC+03:00] Eastern African Time';
|
|
timezoneMap['Asia/Karachi'] = '[UTC+05:00] Pakistan Time';
|
|
timezoneMap['Asia/Kolkata'] = '[UTC+05:30] India Standard Time';
|
|
timezoneMap['Asia/Bangkok'] = '[UTC+05:30] Indochina Time';
|
|
timezoneMap['Asia/Shanghai'] = '[UTC+08:00] China Standard Time';
|
|
timezoneMap['Asia/Kuala_Lumpur'] = '[UTC+08:00] Malaysia Time';
|
|
timezoneMap['Australia/Perth'] = '[UTC+08:00] Western Standard Time (Australia)';
|
|
timezoneMap['Asia/Taipei'] = '[UTC+08:00] Taiwan';
|
|
timezoneMap['Asia/Tokyo'] = '[UTC+09:00] Japan Standard Time';
|
|
timezoneMap['Asia/Seoul'] = '[UTC+09:00] Korea Standard Time';
|
|
timezoneMap['Australia/Adelaide'] = '[UTC+09:30] Central Standard Time (South Australia)';
|
|
timezoneMap['Australia/Darwin'] = '[UTC+09:30] Central Standard Time (Northern Territory)';
|
|
timezoneMap['Australia/Brisbane'] = '[UTC+10:00] Eastern Standard Time (Queensland)';
|
|
timezoneMap['Australia/Canberra'] = '[UTC+10:00] Eastern Standard Time (New South Wales)';
|
|
timezoneMap['Pacific/Guam'] = '[UTC+10:00] Chamorro Standard Time';
|
|
timezoneMap['Pacific/Auckland'] = '[UTC+12:00] New Zealand Standard Time';
|
|
|
|
// CloudStack common API helpers
|
|
cloudStack.api = {
|
|
actions: {
|
|
sort: function(updateCommand, objType) {
|
|
var action = function(args) {
|
|
$.ajax({
|
|
url: createURL(updateCommand),
|
|
data: {
|
|
id: args.context[objType].id,
|
|
sortKey: args.index
|
|
},
|
|
success: function(json) {
|
|
args.response.success();
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
|
|
};
|
|
|
|
return {
|
|
moveTop: {
|
|
action: action
|
|
},
|
|
moveBottom: {
|
|
action: action
|
|
},
|
|
moveUp: {
|
|
action: action
|
|
},
|
|
moveDown: {
|
|
action: action
|
|
},
|
|
moveDrag: {
|
|
action: action
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
tags: function(args) {
|
|
var resourceType = args.resourceType;
|
|
var contextId = args.contextId;
|
|
|
|
return {
|
|
actions: {
|
|
add: function(args) {
|
|
var data = args.data;
|
|
var resourceId = args.context[contextId][0].id;
|
|
|
|
$.ajax({
|
|
url: createURL('createTags'),
|
|
data: {
|
|
'tags[0].key': data.key,
|
|
'tags[0].value': data.value,
|
|
resourceIds: resourceId,
|
|
resourceType: resourceType
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.createtagsresponse.jobid
|
|
},
|
|
notification: {
|
|
desc: 'Add tag for ' + resourceType,
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
remove: function(args) {
|
|
var data = args.context.tagItems[0];
|
|
var resourceId = args.context[contextId][0].id;
|
|
|
|
$.ajax({
|
|
url: createURL('deleteTags'),
|
|
data: {
|
|
'tags[0].key': data.key,
|
|
'tags[0].value': data.value,
|
|
resourceIds: resourceId,
|
|
resourceType: resourceType
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.deletetagsresponse.jobid
|
|
},
|
|
notification: {
|
|
desc: 'Remove tag for ' + resourceType,
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var resourceId = args.context[contextId][0].id;
|
|
var data = {
|
|
resourceId: resourceId,
|
|
resourceType: resourceType
|
|
};
|
|
|
|
if (isAdmin() || isDomainAdmin()) {
|
|
data.listAll = true;
|
|
}
|
|
|
|
if (args.context.projects) {
|
|
data.projectid = args.context.projects[0].id;
|
|
}
|
|
|
|
if (args.jsonObj != null && args.jsonObj.projectid != null && data.projectid == null) {
|
|
data.projectid = args.jsonObj.projectid;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listTags'),
|
|
data: data,
|
|
success: function(json) {
|
|
args.response.success({
|
|
data: json.listtagsresponse ? json.listtagsresponse.tag : []
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
function strOrFunc(arg, args) {
|
|
if (typeof arg === 'function')
|
|
return arg(args);
|
|
return arg;
|
|
}
|