mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
6a11d099cf
-Split 'dictionary.jsp' into two files -> 'dictionary.jsp' and 'dictionary2.jsp' -- this is due to JSP file constraints as the localization object is getting quite long -Per change above, 'dictionary' object is now split into an additonal 'dictionary2' object, which is merged with the main dict object on page load -All new dictionary mappings should be added to 'dictionary2' now. Signed-off-by: Brian Federle <brian.federle@citrix.com>
668 lines
33 KiB
JavaScript
668 lines
33 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.
|
|
(function(cloudStack) {
|
|
cloudStack.sections.domains = {
|
|
title: 'label.menu.domains',
|
|
id: 'domains',
|
|
|
|
// Domain tree
|
|
treeView: {
|
|
// Details
|
|
detailView: {
|
|
name: 'Domain details',
|
|
viewAll: {
|
|
label: 'label.accounts',
|
|
path: 'accounts'
|
|
},
|
|
|
|
// Detail actions
|
|
actions: {
|
|
'delete': {
|
|
label: 'label.action.delete.domain',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.action.delete.domain';
|
|
}
|
|
},
|
|
|
|
createForm: {
|
|
title: 'label.action.delete.domain',
|
|
desc: 'message.action.delete.domain',
|
|
createLabel: 'label.delete',
|
|
preFilter: function(args) {
|
|
if (isAdmin()) {
|
|
args.$form.find('.form-item[rel=isForced]').css('display', 'inline-block');
|
|
}
|
|
},
|
|
fields: {
|
|
isForced: {
|
|
label: 'force.delete',
|
|
isBoolean: true,
|
|
isHidden: true
|
|
}
|
|
}
|
|
},
|
|
|
|
action: function(args) {
|
|
var array1 = [];
|
|
if (args.$form.find('.form-item[rel=isForced]').css("display") != "none") //uncomment after Brian fix it to include $form in args
|
|
array1.push("&cleanup=" + (args.data.isForced == "on"));
|
|
|
|
$.ajax({
|
|
url: createURL("deleteDomain&id=" + args.context.domains[0].id + array1.join("")),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var jid = json.deletedomainresponse.jobid;
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: jid
|
|
}
|
|
});
|
|
|
|
// Quick fix for proper UI reaction to delete domain
|
|
var $item = $('.name.selected').closest('li');
|
|
var $itemParent = $item.closest('li');
|
|
$itemParent.parent().parent().find('.name:first').click();
|
|
$item.remove();
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
|
|
// Edit domain
|
|
edit: {
|
|
label: 'label.action.edit.domain',
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.action.edit.domain';
|
|
}
|
|
},
|
|
action: function(args) {
|
|
var domainObj;
|
|
|
|
var data = {
|
|
id: args.context.domains[0].id
|
|
};
|
|
|
|
if (args.data.name != null) { //args.data.name == undefined means name field is not editable (when log in as normal user or domain admin)
|
|
$.extend(data, {
|
|
name: args.data.name
|
|
});
|
|
}
|
|
|
|
if (args.data.networkdomain != null) { //args.data.networkdomain == undefined means networkdomain field is not editable (when log in as normal user or domain admin)
|
|
$.extend(data, {
|
|
networkdomain: args.data.networkdomain
|
|
});
|
|
}
|
|
|
|
if('name' in data || 'networkdomain' in data) {
|
|
$.ajax({
|
|
url: createURL("updateDomain"),
|
|
async: false,
|
|
data: data,
|
|
success: function(json) {
|
|
domainObj = json.updatedomainresponse.domain;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.vmLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=0&max=" + args.data.vmLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["vmLimit"] = args.data.vmLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.ipLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=1&max=" + args.data.ipLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["ipLimit"] = args.data.ipLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.volumeLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=2&max=" + args.data.volumeLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["volumeLimit"] = args.data.volumeLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.snapshotLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=3&max=" + args.data.snapshotLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["snapshotLimit"] = args.data.snapshotLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.templateLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=4&max=" + args.data.templateLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["templateLimit"] = args.data.templateLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.vpcLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=7&max=" + args.data.vpcLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["vpcLimit"] = args.data.vpcLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.cpuLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=8&max=" + args.data.cpuLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["cpuLimit"] = args.data.cpuLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.memoryLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=9&max=" + args.data.memoryLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["memoryLimit"] = args.data.memoryLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.networkLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=6&max=" + args.data.networkLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["networkLimit"] = args.data.networkLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.primaryStorageLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=10&max=" + args.data.primaryStorageLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["primaryStorageLimit"] = args.data.primaryStorageLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (args.data.secondaryStorageLimit != null) {
|
|
$.ajax({
|
|
url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=11&max=" + args.data.secondaryStorageLimit),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
domainObj["secondaryStorageLimit"] = args.data.secondaryStorageLimit;
|
|
}
|
|
});
|
|
}
|
|
|
|
args.response.success({
|
|
data: domainObj
|
|
});
|
|
}
|
|
},
|
|
|
|
// Add domain
|
|
create: {
|
|
label: 'label.add.domain',
|
|
|
|
action: function(args) {
|
|
var data = {
|
|
parentdomainid: args.context.domains[0].id,
|
|
name: args.data.name
|
|
};
|
|
|
|
if (args.data.networkdomain != null && args.data.networkdomain.length > 0) {
|
|
$.extend(data, {
|
|
networkdomain: args.data.networkdomain
|
|
});
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('createDomain'),
|
|
data: data,
|
|
success: function(json) {
|
|
var item = json.createdomainresponse.domain;
|
|
args.response.success({
|
|
data: item
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
|
|
args.response.error(errorMsg);
|
|
}
|
|
});
|
|
},
|
|
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.add.domain';
|
|
}
|
|
},
|
|
|
|
createForm: {
|
|
title: 'label.add.domain',
|
|
desc: 'message.add.domain',
|
|
fields: {
|
|
name: {
|
|
label: 'label.name',
|
|
docID: 'helpDomainName',
|
|
validation: {
|
|
required: true
|
|
}
|
|
},
|
|
networkdomain: {
|
|
label: 'label.network.domain',
|
|
docID: 'helpDomainNetworkDomain',
|
|
validation: {
|
|
required: false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
updateResourceCount: {
|
|
label: 'label.action.update.resource.count',
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.update.resource.count';
|
|
},
|
|
notification: function(args) {
|
|
return 'label.action.update.resource.count';
|
|
}
|
|
},
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL("updateResourceCount&domainid=" + args.context.domains[0].id),
|
|
dataType: "json",
|
|
async: true,
|
|
success: function(json) {
|
|
//var resourcecounts= json.updateresourcecountresponse.resourcecount; //do nothing
|
|
args.response.success();
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: function(args) {
|
|
args.complete();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
tabs: {
|
|
details: {
|
|
title: 'label.details',
|
|
fields: [{
|
|
name: {
|
|
label: 'label.name',
|
|
isEditable: function(args) {
|
|
if (isAdmin() && args.domains[0].level != 0) //ROOT domain (whose level is 0) is not allowed to change domain name
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
}, {
|
|
id: {
|
|
label: 'label.id'
|
|
},
|
|
|
|
path: {
|
|
label: 'label.full.path'
|
|
},
|
|
|
|
networkdomain: {
|
|
label: 'label.network.domain',
|
|
isEditable: function(args) {
|
|
if (isAdmin())
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
},
|
|
vmLimit: {
|
|
label: 'label.instance.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
ipLimit: {
|
|
label: 'label.ip.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
volumeLimit: {
|
|
label: 'label.volume.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
snapshotLimit: {
|
|
label: 'label.snapshot.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
templateLimit: {
|
|
label: 'label.template.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
vpcLimit: {
|
|
label: 'label.VPC.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
cpuLimit: {
|
|
label: 'label.cpu.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
memoryLimit: {
|
|
label: 'label.memory.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
networkLimit: {
|
|
label: 'label.network.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
primaryStorageLimit: {
|
|
label: 'label.primary.storage.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
secondaryStorageLimit: {
|
|
label: 'label.secondary.storage.limits',
|
|
isEditable: function(args) {
|
|
if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
accountTotal: {
|
|
label: 'label.accounts'
|
|
},
|
|
vmTotal: {
|
|
label: 'label.instances'
|
|
},
|
|
volumeTotal: {
|
|
label: 'label.volumes'
|
|
}
|
|
}],
|
|
dataProvider: function(args) {
|
|
var domainObj = args.context.domains[0];
|
|
var totalVMs = 0;
|
|
var totalVolumes = 0;
|
|
|
|
$.ajax({
|
|
url: createURL("listAccounts&domainid=" + domainObj.id),
|
|
async: false,
|
|
data: {
|
|
details: 'min'
|
|
},
|
|
success: function(json) {
|
|
var items = json.listaccountsresponse.account;
|
|
if (items != null) {
|
|
domainObj["accountTotal"] = items.length;
|
|
for (var i = 0; i < items.length; i++) {
|
|
totalVMs += items[i].vmtotal;
|
|
totalVolumes += items[i].volumetotal;
|
|
}
|
|
} else {
|
|
domainObj["accountTotal"] = 0;
|
|
}
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL("listProjects&domainid=" + domainObj.id),
|
|
async: false,
|
|
data: {
|
|
details: 'min'
|
|
},
|
|
success: function(json) {
|
|
var items = json.listprojectsresponse.project;
|
|
if (items != null) {
|
|
for (var i = 0; i < items.length; i++) {
|
|
totalVMs += items[i].vmtotal;
|
|
totalVolumes += items[i].volumetotal;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
domainObj["vmTotal"] = totalVMs;
|
|
domainObj["volumeTotal"] = totalVolumes;
|
|
|
|
/* $.ajax({
|
|
url: createURL("listVirtualMachines&details=min&domainid=" + domainObj.id),
|
|
async: false,
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var items = json.listvirtualmachinesresponse.virtualmachine;
|
|
var total;
|
|
if (items != null)
|
|
total = items.length;
|
|
else
|
|
total = 0;
|
|
domainObj["vmTotal"] = total;
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL("listVolumes&domainid=" + domainObj.id),
|
|
async: false,
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var items = json.listvolumesresponse.volume;
|
|
var total;
|
|
if (items != null)
|
|
total = items.length;
|
|
else
|
|
total = 0;
|
|
domainObj["volumeTotal"] = total;
|
|
}
|
|
});*/
|
|
|
|
$.ajax({
|
|
url: createURL("listResourceLimits&domainid=" + domainObj.id),
|
|
async: false,
|
|
dataType: "json",
|
|
success: function(json) {
|
|
var limits = json.listresourcelimitsresponse.resourcelimit;
|
|
if (limits != null) {
|
|
for (var i = 0; i < limits.length; i++) {
|
|
var limit = limits[i];
|
|
switch (limit.resourcetype) {
|
|
case "0":
|
|
domainObj["vmLimit"] = limit.max;
|
|
break;
|
|
case "1":
|
|
domainObj["ipLimit"] = limit.max;
|
|
break;
|
|
case "2":
|
|
domainObj["volumeLimit"] = limit.max;
|
|
break;
|
|
case "3":
|
|
domainObj["snapshotLimit"] = limit.max;
|
|
break;
|
|
case "4":
|
|
domainObj["templateLimit"] = limit.max;
|
|
break;
|
|
case "6":
|
|
domainObj["networkLimit"] = limit.max;
|
|
break;
|
|
case "7":
|
|
domainObj["vpcLimit"] = limit.max;
|
|
break;
|
|
case "8":
|
|
domainObj["cpuLimit"] = limit.max;
|
|
break;
|
|
case "9":
|
|
domainObj["memoryLimit"] = limit.max;
|
|
break;
|
|
case "10":
|
|
domainObj["primaryStorageLimit"] = limit.max;
|
|
break;
|
|
case "11":
|
|
domainObj["secondaryStorageLimit"] = limit.max;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
args.response.success({
|
|
data: domainObj,
|
|
actionFilter: domainActionfilter
|
|
});
|
|
}
|
|
}
|
|
}
|
|
},
|
|
labelField: 'name',
|
|
dataProvider: function(args) {
|
|
var parentDomain = args.context.parentDomain;
|
|
if (parentDomain == null) { //draw root node
|
|
$.ajax({
|
|
url: createURL("listDomains&id=" + g_domainid + '&listAll=true'),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var domainObjs = json.listdomainsresponse.domain;
|
|
args.response.success({
|
|
actionFilter: domainActionfilter,
|
|
data: domainObjs
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
$.ajax({
|
|
url: createURL("listDomainChildren&id=" + parentDomain.id),
|
|
dataType: "json",
|
|
async: false,
|
|
success: function(json) {
|
|
var domainObjs = json.listdomainchildrenresponse.domain;
|
|
args.response.success({
|
|
actionFilter: domainActionfilter,
|
|
data: domainObjs
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var domainActionfilter = function(args) {
|
|
var jsonObj = args.context.item;
|
|
var allowedActions = [];
|
|
if (isAdmin()) {
|
|
allowedActions.push("create");
|
|
allowedActions.push("edit"); //merge updateResourceLimit into edit
|
|
if (jsonObj.level != 0) { //ROOT domain (whose level is 0) is not allowed to delete
|
|
allowedActions.push("delete");
|
|
}
|
|
} else if (isDomainAdmin()) {
|
|
if (args.context.domains[0].id != g_domainid) {
|
|
allowedActions.push("edit"); //merge updateResourceLimit into edit
|
|
}
|
|
}
|
|
allowedActions.push("updateResourceCount");
|
|
return allowedActions;
|
|
}
|
|
|
|
})(cloudStack);
|