mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
1347 lines
59 KiB
JavaScript
1347 lines
59 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) {
|
|
var getProjectAdmin, selectedProjectObj;
|
|
cloudStack.projects = {
|
|
requireInvitation: function(args) {
|
|
return g_capabilities.projectinviterequired;
|
|
},
|
|
|
|
invitationCheck: function(args) {
|
|
$.ajax({
|
|
url: createURL('listProjectInvitations'),
|
|
data: {
|
|
state: 'Pending'
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
data: json.listprojectinvitationsresponse.projectinvitation ? json.listprojectinvitationsresponse.projectinvitation : []
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
resourceManagement: {
|
|
update: function(args, projectID) {
|
|
var totalResources = 5;
|
|
var updatedResources = 0;
|
|
|
|
projectID = projectID ? projectID : cloudStack.context.projects[0].id;
|
|
|
|
$.each(args.data, function(key, value) {
|
|
$.ajax({
|
|
url: createURL('updateResourceLimit', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectid: projectID,
|
|
resourcetype: key,
|
|
max: args.data[key]
|
|
},
|
|
success: function(json) {
|
|
updatedResources++;
|
|
if (updatedResources == totalResources) {
|
|
args.response.success();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
dataProvider: function(args, projectID) {
|
|
projectID = projectID ? projectID : cloudStack.context.projects[0].id;
|
|
|
|
$.ajax({
|
|
url: createURL('listResourceLimits', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectid: projectID
|
|
},
|
|
success: function(json) {
|
|
var resourceLimits = $.grep(
|
|
json.listresourcelimitsresponse.resourcelimit,
|
|
function(resourceLimit) {
|
|
return resourceLimit.resourcetype != 5 && resourceLimit.resourcetype != 12;
|
|
}
|
|
);
|
|
|
|
args.response.success({
|
|
data: $.map(
|
|
resourceLimits,
|
|
function(resource) {
|
|
var resourceMap = {
|
|
0: {
|
|
id: 'user_vm',
|
|
label: 'label.max.vms'
|
|
},
|
|
1: {
|
|
id: 'public_ip',
|
|
label: 'label.max.public.ips'
|
|
},
|
|
2: {
|
|
id: 'volume',
|
|
label: 'label.max.volumes'
|
|
},
|
|
3: {
|
|
id: 'snapshot',
|
|
label: 'label.max.snapshots'
|
|
},
|
|
4: {
|
|
id: 'template',
|
|
label: 'label.max.templates'
|
|
},
|
|
5: {
|
|
id: 'project',
|
|
label: 'label.max.projects'
|
|
},
|
|
6: {
|
|
id: 'network',
|
|
label: 'label.max.networks'
|
|
},
|
|
7: {
|
|
id: 'vpc',
|
|
label: 'label.max.vpcs'
|
|
},
|
|
8: {
|
|
id: 'cpu',
|
|
label: 'label.max.cpus'
|
|
},
|
|
9: {
|
|
id: 'memory',
|
|
label: 'label.max.memory'
|
|
},
|
|
10: {
|
|
id: 'primary_storage',
|
|
label: 'label.max.primary.storage'
|
|
},
|
|
11: {
|
|
id: 'secondary_storage',
|
|
label: 'label.max.secondary.storage'
|
|
}
|
|
};
|
|
|
|
return {
|
|
id: resourceMap[resource.resourcetype].id,
|
|
label: _l(resourceMap[resource.resourcetype].label),
|
|
type: resource.resourcetype,
|
|
value: resource.max
|
|
};
|
|
}
|
|
)
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
dashboard: function(args) {
|
|
var dataFns = {
|
|
instances: function(data) {
|
|
$.ajax({
|
|
url: createURL('listVirtualMachines'),
|
|
success: function(json) {
|
|
var instances = json.listvirtualmachinesresponse.virtualmachine ?
|
|
json.listvirtualmachinesresponse.virtualmachine : [];
|
|
|
|
dataFns.storage($.extend(data, {
|
|
runningInstances: $.grep(instances, function(instance) {
|
|
return instance.state == 'Running';
|
|
}).length,
|
|
stoppedInstances: $.grep(instances, function(instance) {
|
|
return instance.state != 'Running';
|
|
}).length,
|
|
totalInstances: instances.length
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
storage: function(data) {
|
|
$.ajax({
|
|
url: createURL('listVolumes'),
|
|
success: function(json) {
|
|
dataFns.bandwidth($.extend(data, {
|
|
totalVolumes: json.listvolumesresponse.volume ? json.listvolumesresponse.count : 0
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
bandwidth: function(data) {
|
|
var totalBandwidth = 0;
|
|
$.ajax({
|
|
url: createURL('listNetworks'),
|
|
success: function(json) {
|
|
var networks = json.listnetworksresponse.network ?
|
|
json.listnetworksresponse.network : [];
|
|
$(networks).each(function() {
|
|
var network = this;
|
|
$.ajax({
|
|
url: createURL('listNetworkOfferings'),
|
|
async: false,
|
|
data: {
|
|
id: network.networkofferingid
|
|
},
|
|
success: function(json) {
|
|
totalBandwidth +=
|
|
json.listnetworkofferingsresponse.networkoffering[0].networkrate;
|
|
}
|
|
});
|
|
});
|
|
|
|
dataFns.ipAddresses($.extend(data, {
|
|
totalBandwidth: totalBandwidth
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
ipAddresses: function(data) {
|
|
$.ajax({
|
|
url: createURL('listPublicIpAddresses'),
|
|
success: function(json) {
|
|
dataFns.loadBalancingRules($.extend(data, {
|
|
totalIPAddresses: json.listpublicipaddressesresponse.count ? json.listpublicipaddressesresponse.count : 0
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
loadBalancingRules: function(data) {
|
|
$.ajax({
|
|
url: createURL('listLoadBalancerRules'),
|
|
success: function(json) {
|
|
dataFns.portForwardingRules($.extend(data, {
|
|
totalLoadBalancers: json.listloadbalancerrulesresponse.count ? json.listloadbalancerrulesresponse.count : 0
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
portForwardingRules: function(data) {
|
|
$.ajax({
|
|
url: createURL('listPortForwardingRules'),
|
|
success: function(json) {
|
|
dataFns.users($.extend(data, {
|
|
totalPortForwards: json.listportforwardingrulesresponse.count ? json.listportforwardingrulesresponse.count : 0
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
users: function(data) {
|
|
$.ajax({
|
|
url: createURL('listProjectAccounts'),
|
|
success: function(json) {
|
|
var users = json.listprojectaccountsresponse.projectaccount;
|
|
|
|
dataFns.events($.extend(data, {
|
|
users: $.map(users, function(user) {
|
|
return {
|
|
account: user.account
|
|
};
|
|
})
|
|
}));
|
|
}
|
|
});
|
|
},
|
|
|
|
events: function(data) {
|
|
$.ajax({
|
|
url: createURL('listEvents', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
page: 1,
|
|
pageSize: 8
|
|
},
|
|
success: function(json) {
|
|
var events = json.listeventsresponse.event;
|
|
|
|
complete($.extend(data, {
|
|
events: $.map(events, function(event) {
|
|
return {
|
|
date: event.created.substr(5, 2) + '/' + event.created.substr(8, 2) + '/' + event.created.substr(2, 2),
|
|
desc: event.description
|
|
};
|
|
})
|
|
}));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
var complete = function(data) {
|
|
args.response.success({
|
|
data: data
|
|
});
|
|
};
|
|
|
|
dataFns.instances();
|
|
},
|
|
|
|
add: function(args) {
|
|
setTimeout(function() {
|
|
$.ajax({
|
|
url: createURL('createProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
account: args.context.users[0].account,
|
|
domainId: args.context.users[0].domainid,
|
|
name: args.data['project-name'],
|
|
displayText: args.data['project-display-text']
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
data: {
|
|
id: data.createprojectresponse.id,
|
|
name: args.data['project-name'],
|
|
displayText: args.data['project-display-text'],
|
|
users: []
|
|
}
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
}, 100);
|
|
},
|
|
inviteForm: {
|
|
noSelect: true,
|
|
noHeaderActionsColumn: true,
|
|
ignoreEmptyFields: true,
|
|
fields: {
|
|
'email': {
|
|
edit: true,
|
|
label: 'label.email'
|
|
},
|
|
'account': {
|
|
edit: true,
|
|
label: 'label.account'
|
|
},
|
|
'state': {
|
|
edit: 'ignore',
|
|
label: 'label.status'
|
|
},
|
|
'add-user': {
|
|
addButton: true,
|
|
label: ''
|
|
}
|
|
},
|
|
add: {
|
|
label: 'label.invite',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('addAccountToProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectId: args.context.projects[0].id,
|
|
account: args.data.account,
|
|
email: args.data.email
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
data: args.data,
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.addaccounttoprojectresponse.jobid
|
|
},
|
|
notification: {
|
|
label: 'label.project.invite',
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
}
|
|
},
|
|
actionPreFilter: function(args) {
|
|
if (args.context.projects &&
|
|
args.context.projects[0] && !args.context.projects[0].isNew) {
|
|
return args.context.actions;
|
|
}
|
|
|
|
return ['destroy'];
|
|
},
|
|
|
|
actions: {
|
|
destroy: {
|
|
label: 'label.revoke.project.invite',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('deleteProjectInvitation'),
|
|
data: {
|
|
id: args.context.multiRule[0].id
|
|
},
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.deleteprojectinvitationresponse.jobid
|
|
},
|
|
notification: {
|
|
label: 'label.revoke.project.invite',
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
// Project users data provider
|
|
dataProvider: function(args) {
|
|
$.ajax({
|
|
url: createURL('listProjectInvitations', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
state: 'Pending',
|
|
listAll: true,
|
|
projectId: args.context.projects[0].id
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
var invites = data.listprojectinvitationsresponse.projectinvitation ?
|
|
data.listprojectinvitationsresponse.projectinvitation : [];
|
|
args.response.success({
|
|
data: $.map(invites, function(elem) {
|
|
return {
|
|
id: elem.id,
|
|
account: elem.account,
|
|
email: elem.email,
|
|
state: elem.state
|
|
};
|
|
})
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
addUserForm: {
|
|
noSelect: true,
|
|
hideForm: function() {
|
|
return g_capabilities.projectinviterequired;
|
|
},
|
|
fields: {
|
|
'username': {
|
|
edit: true,
|
|
label: 'label.account'
|
|
},
|
|
'role': {
|
|
edit: 'ignore',
|
|
label: 'label.role'
|
|
},
|
|
'add-user': {
|
|
addButton: true,
|
|
label: ''
|
|
}
|
|
},
|
|
add: {
|
|
label: 'label.add.account',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('addAccountToProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectId: args.context.projects[0].id,
|
|
account: args.data.username
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.addaccounttoprojectresponse.jobid
|
|
},
|
|
notification: {
|
|
label: 'label.add.account.to.project',
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
|
|
if (g_capabilities.projectinviterequired) {
|
|
cloudStack.dialog.notice({
|
|
message: 'message.project.invite.sent'
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
},
|
|
actionPreFilter: function(args) {
|
|
if (!args.context.projects &&
|
|
args.context.multiRule[0].role != 'Admin') { // This is for the new project wizard
|
|
return ['destroy'];
|
|
}
|
|
|
|
if (args.context.multiRule[0].role != 'Admin' &&
|
|
(cloudStack.context.users[0].account == getProjectAdmin || isAdmin() || isDomainAdmin())) { // This is for the new project wizard: check if current logged in User is the Project Owner
|
|
return args.context.actions;
|
|
}
|
|
|
|
return [];
|
|
},
|
|
readOnlyCheck: function(args) { // check if current logged in User is the Project Owner
|
|
if (isAdmin() || isDomainAdmin())
|
|
return true;
|
|
|
|
var projectOwner, currentUser = cloudStack.context.users[0].account;
|
|
$(args.data).each(function() {
|
|
var data = this;
|
|
if (data.role == 'Admin')
|
|
projectOwner = data.username;
|
|
});
|
|
if (projectOwner == currentUser)
|
|
return true;
|
|
|
|
return false;
|
|
},
|
|
actions: {
|
|
destroy: {
|
|
label: 'label.remove.project.account',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('deleteAccountFromProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectId: args.context.projects[0].id,
|
|
account: args.context.multiRule[0].username
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.deleteaccountfromprojectresponse.jobid
|
|
},
|
|
notification: {
|
|
label: 'label.remove.project.account',
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
},
|
|
error: function(data) {
|
|
args.response.error('Could not remove user');
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
makeOwner: {
|
|
label: 'label.make.project.owner',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('updateProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
id: args.context.projects[0].id,
|
|
account: args.context.multiRule[0].username
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.updateprojectresponse.jobid,
|
|
onComplete: function() {
|
|
setTimeout(function() {
|
|
$(window).trigger('cloudStack.fullRefresh');
|
|
if (isUser()) {
|
|
$(window).trigger('cloudStack.detailsRefresh');
|
|
}
|
|
}, 500);
|
|
}
|
|
},
|
|
notification: {
|
|
label: 'label.make.project.owner',
|
|
poll: pollAsyncJobResult
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
// Project users data provider
|
|
dataProvider: function(args) {
|
|
$.ajax({
|
|
url: createURL('listProjectAccounts', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
projectId: args.context.projects[0].id
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
data: $.map(data.listprojectaccountsresponse.projectaccount, function(elem) {
|
|
if (elem.role == 'Owner' || elem.role == 'Admin')
|
|
getProjectAdmin = elem.account;
|
|
return {
|
|
id: elem.accountid,
|
|
role: elem.role,
|
|
username: elem.role == 'Owner' ? elem.account + ' (owner)' : elem.account
|
|
};
|
|
})
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
// Project listing data provider
|
|
dataProvider: function(args) {
|
|
var user = args.context.users[0];
|
|
var data1 = {
|
|
accountId: user.userid,
|
|
listAll: true
|
|
};
|
|
if (args.projectName) {
|
|
data1.keyword = args.projectName;
|
|
}
|
|
|
|
var array1 = [];
|
|
var page = 1;
|
|
var getNextPage = function() {
|
|
var data2 = $.extend({}, data1, {
|
|
page: page,
|
|
pageSize: 500
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL('listProjects', {
|
|
ignoreProject: true
|
|
}),
|
|
data: data2,
|
|
async: false,
|
|
success: function(json) {
|
|
var projects = json.listprojectsresponse.project;
|
|
if (projects != undefined) {
|
|
for(var i = 0; i < projects.length; i++) {
|
|
array1.push($.extend(projects[i], {
|
|
displayText: projects[i].displaytext
|
|
}));
|
|
}
|
|
}
|
|
if (array1.length < json.listprojectsresponse.count) {
|
|
page++;
|
|
getNextPage();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
getNextPage();
|
|
args.response.success({ data: array1 });
|
|
}
|
|
};
|
|
|
|
cloudStack.sections.projects = {
|
|
title: 'label.projects',
|
|
id: 'projects',
|
|
sectionSelect: {
|
|
label: 'label.select-view'
|
|
},
|
|
sections: {
|
|
projects: {
|
|
type: 'select',
|
|
id: 'projects',
|
|
title: 'label.projects',
|
|
listView: {
|
|
fields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
displaytext: {
|
|
label: 'label.display.name'
|
|
},
|
|
domain: {
|
|
label: 'label.domain'
|
|
},
|
|
account: {
|
|
label: 'label.owner.account'
|
|
},
|
|
state: {
|
|
label: 'label.status',
|
|
indicator: {
|
|
'Active': 'on',
|
|
'Destroyed': 'off',
|
|
'Disabled': 'off',
|
|
'Left Project': 'off'
|
|
}
|
|
}
|
|
},
|
|
|
|
advSearchFields: {
|
|
name: {
|
|
label: 'label.name'
|
|
},
|
|
displaytext: {
|
|
label: 'label.display.text'
|
|
},
|
|
|
|
domainid: {
|
|
label: 'label.domain',
|
|
select: function(args) {
|
|
if (isAdmin() || isDomainAdmin()) {
|
|
$.ajax({
|
|
url: createURL('listDomains'),
|
|
data: {
|
|
listAll: true,
|
|
details: 'min'
|
|
},
|
|
success: function(json) {
|
|
var array1 = [{
|
|
id: '',
|
|
description: ''
|
|
}];
|
|
var domains = json.listdomainsresponse.domain;
|
|
if (domains != null && domains.length > 0) {
|
|
for (var i = 0; i < domains.length; i++) {
|
|
array1.push({
|
|
id: domains[i].id,
|
|
description: domains[i].path
|
|
});
|
|
}
|
|
}
|
|
array1.sort(function(a, b) {
|
|
return a.description.localeCompare(b.description);
|
|
});
|
|
args.response.success({
|
|
data: array1
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
args.response.success({
|
|
data: null
|
|
});
|
|
}
|
|
},
|
|
isHidden: function(args) {
|
|
if (isAdmin() || isDomainAdmin())
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
|
|
account: {
|
|
label: 'label.account',
|
|
isHidden: function(args) {
|
|
if (isAdmin() || isDomainAdmin())
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
},
|
|
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
|
|
if (isDomainAdmin()) {
|
|
$.extend(data, {
|
|
domainid: args.context.users[0].domainid
|
|
});
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listProjects', {
|
|
ignoreProject: true
|
|
}),
|
|
data: data,
|
|
success: function(data) {
|
|
args.response.success({
|
|
data: data.listprojectsresponse.project,
|
|
actionFilter: projectsActionFilter
|
|
});
|
|
},
|
|
error: function(XMLHttpResponse) {
|
|
cloudStack.dialog.notice({
|
|
message: parseXMLHttpResponse(XMLHttpResponse)
|
|
});
|
|
args.response.error();
|
|
}
|
|
});
|
|
},
|
|
|
|
actions: {
|
|
add: {
|
|
label: 'label.new.project',
|
|
action: {
|
|
custom: function(args) {
|
|
$(window).trigger('cloudStack.newProject');
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
detailView: {
|
|
updateContext: function(args) {
|
|
var project;
|
|
var projectID = args.context.projects[0].id;
|
|
var url = 'listProjects';
|
|
if (isDomainAdmin()) {
|
|
url += '&domainid=' + args.context.users[0].domainid;
|
|
}
|
|
$.ajax({
|
|
url: createURL(url),
|
|
data: {
|
|
listAll: true,
|
|
id: projectID
|
|
},
|
|
async: false,
|
|
success: function(json) {
|
|
project = json.listprojectsresponse.project[0]; // override project after update owner
|
|
}
|
|
});
|
|
selectedProjectObj = project;
|
|
|
|
return {
|
|
projects: [project]
|
|
};
|
|
},
|
|
actions: {
|
|
edit: {
|
|
label: 'label.edit',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('updateProject'),
|
|
data: $.extend(true, {}, args.context.projects[0], args.data),
|
|
success: function(json) {
|
|
args.response.success();
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
notification: function(args) {
|
|
return 'label.edit.project.details';
|
|
}
|
|
}
|
|
},
|
|
disable: {
|
|
label: 'label.suspend.project',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('suspendProject'),
|
|
data: {
|
|
id: args.context.projects[0].id
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.suspendprojectresponse.jobid,
|
|
getUpdatedItem: function() {
|
|
return {
|
|
state: 'Suspended'
|
|
};
|
|
}
|
|
}
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
confirm: function() {
|
|
return 'message.suspend.project';
|
|
},
|
|
notification: function() {
|
|
return 'label.suspend.project';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
|
|
enable: {
|
|
label: 'label.activate.project',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('activateProject'),
|
|
data: {
|
|
id: args.context.projects[0].id
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.activaterojectresponse.jobid, // NOTE: typo
|
|
getUpdatedItem: function() {
|
|
return {
|
|
state: 'Active'
|
|
};
|
|
}
|
|
}
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
confirm: function() {
|
|
return 'message.activate.project';
|
|
},
|
|
notification: function() {
|
|
return 'label.activate.project';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
|
|
remove: {
|
|
label: 'label.delete.project',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('deleteProject', {
|
|
ignoreProject: true
|
|
}),
|
|
data: {
|
|
id: args.data.id
|
|
},
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
getUpdatedItem: function(data) {
|
|
return $.extend(data, {
|
|
state: 'Destroyed'
|
|
});
|
|
},
|
|
onComplete: function(data) {
|
|
$(window).trigger('cloudStack.deleteProject', args);
|
|
},
|
|
getActionFilter: function(args) {
|
|
return function() {
|
|
return [];
|
|
};
|
|
},
|
|
jobId: data.deleteprojectresponse.jobid
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
messages: {
|
|
confirm: function(args) {
|
|
return 'message.delete.project';
|
|
},
|
|
notification: function(args) {
|
|
return 'label.delete.project';
|
|
}
|
|
},
|
|
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
}
|
|
},
|
|
|
|
tabFilter: function(args) {
|
|
var project = selectedProjectObj;
|
|
var projectOwner = project.account;
|
|
var currentAccount = args.context.users[0].account;
|
|
var hiddenTabs = [];
|
|
|
|
if (!isAdmin() && !isDomainAdmin()) {
|
|
hiddenTabs.push('resources');
|
|
|
|
if (currentAccount != projectOwner) {
|
|
hiddenTabs.push('accounts');
|
|
hiddenTabs.push('invitations');
|
|
}
|
|
}
|
|
|
|
if (!cloudStack.projects.requireInvitation()) {
|
|
hiddenTabs.push('invitations');
|
|
}
|
|
|
|
return hiddenTabs;
|
|
},
|
|
tabs: {
|
|
details: {
|
|
title: 'label.details',
|
|
fields: [{
|
|
name: {
|
|
label: 'label.name'
|
|
}
|
|
}, {
|
|
displaytext: {
|
|
label: 'label.display.name',
|
|
isEditable: true
|
|
},
|
|
id: {
|
|
label: 'label.id'
|
|
},
|
|
domain: {
|
|
label: 'label.domain'
|
|
},
|
|
account: {
|
|
label: 'label.account'
|
|
},
|
|
state: {
|
|
label: 'label.state'
|
|
}
|
|
}, {
|
|
vmtotal: {
|
|
label: 'label.total.vms'
|
|
},
|
|
memorytotal: {
|
|
label: 'label.memory.total'
|
|
},
|
|
cputotal: {
|
|
label: 'label.total.cpu'
|
|
},
|
|
volumetotal: {
|
|
label: 'label.volume'
|
|
},
|
|
primarystoragetotal: {
|
|
label: 'label.primary.storage'
|
|
},
|
|
iptotal: {
|
|
label: 'label.total.of.ip'
|
|
},
|
|
templatetotal: {
|
|
label: 'label.template'
|
|
}
|
|
}],
|
|
|
|
tags: cloudStack.api.tags({
|
|
resourceType: 'Project',
|
|
contextId: 'projects'
|
|
}),
|
|
|
|
dataProvider: function(args) {
|
|
var projectID = args.context.projects[0].id;
|
|
|
|
var url = 'listProjects';
|
|
|
|
if (isDomainAdmin()) {
|
|
url += '&domainid=' + args.context.users[0].domainid;
|
|
}
|
|
$.ajax({
|
|
url: createURL(url),
|
|
data: {
|
|
listAll: true,
|
|
id: projectID
|
|
},
|
|
success: function(json) {
|
|
args.response.success({
|
|
data: json.listprojectsresponse.project ? json.listprojectsresponse.project[0] : {},
|
|
actionFilter: projectsActionFilter
|
|
});
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
accounts: {
|
|
title: 'label.accounts',
|
|
custom: function(args) {
|
|
var project = args.context.projects[0];
|
|
var multiEditArgs = $.extend(
|
|
true, {},
|
|
cloudStack.projects.addUserForm, {
|
|
context: {
|
|
projects: [project]
|
|
}
|
|
}
|
|
);
|
|
var $users = $('<div>').multiEdit(multiEditArgs);
|
|
|
|
return $users;
|
|
}
|
|
},
|
|
|
|
invitations: {
|
|
title: 'label.invitations',
|
|
custom: function(args) {
|
|
var project = args.context.projects[0];
|
|
var $invites = cloudStack.uiCustom.projectsTabs.userManagement({
|
|
useInvites: true,
|
|
context: {
|
|
projects: [project]
|
|
}
|
|
});
|
|
|
|
return $invites;
|
|
}
|
|
},
|
|
|
|
resources: {
|
|
title: 'label.resources',
|
|
custom: function(args) {
|
|
var $resources = cloudStack.uiCustom
|
|
.projectsTabs.dashboardTabs.resources({
|
|
projectID: args.context.projects[0].id
|
|
});
|
|
|
|
return $('<div>').addClass('project-dashboard').append($resources);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
invitations: {
|
|
type: 'select',
|
|
id: 'invitations',
|
|
title: 'label.invitations',
|
|
listView: {
|
|
fields: {
|
|
project: {
|
|
label: 'label.project'
|
|
},
|
|
domain: {
|
|
label: 'label.domain'
|
|
},
|
|
state: {
|
|
label: 'label.status',
|
|
indicator: {
|
|
'Accepted': 'on',
|
|
'Completed': 'on',
|
|
'Pending': 'off',
|
|
'Declined': 'off'
|
|
}
|
|
}
|
|
},
|
|
|
|
dataProvider: function(args) {
|
|
$.ajax({
|
|
url: createURL('listProjectInvitations'),
|
|
data: {
|
|
state: 'Pending'
|
|
},
|
|
success: function(data) {
|
|
args.response.success({
|
|
actionFilter: projectInvitationActionFilter,
|
|
data: data.listprojectinvitationsresponse.projectinvitation ? data.listprojectinvitationsresponse.projectinvitation : []
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
actions: {
|
|
enterToken: {
|
|
label: 'label.enter.token',
|
|
isHeader: true,
|
|
addRow: false,
|
|
preFilter: function(args) {
|
|
var invitationsPresent = false;
|
|
|
|
$.ajax({
|
|
url: createURL('listProjectInvitations'),
|
|
data: {
|
|
state: 'Pending'
|
|
},
|
|
async: false,
|
|
success: function(json) {
|
|
if (json.listprojectinvitationsresponse.count) {
|
|
invitationsPresent = true;
|
|
}
|
|
}
|
|
});
|
|
|
|
return !invitationsPresent;
|
|
},
|
|
createForm: {
|
|
desc: 'message.enter.token',
|
|
fields: {
|
|
projectid: {
|
|
label: 'label.project.id',
|
|
validation: {
|
|
required: true
|
|
},
|
|
docID: 'helpEnterTokenProjectID'
|
|
},
|
|
token: {
|
|
label: 'label.token',
|
|
docID: 'helpEnterTokenToken',
|
|
validation: {
|
|
required: true
|
|
}
|
|
}
|
|
}
|
|
},
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('updateProjectInvitation'),
|
|
data: args.data,
|
|
success: function(json) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: json.updateprojectinvitationresponse.jobid
|
|
}
|
|
});
|
|
},
|
|
error: function(json) {
|
|
args.response.error(parseXMLHttpResponse(json));
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
notification: function() {
|
|
return 'label.accept.project.invitation';
|
|
},
|
|
complete: function() {
|
|
return 'message.join.project';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
|
|
accept: {
|
|
label: 'label.accept.project.invitation',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('updateProjectInvitation'),
|
|
data: {
|
|
projectid: args.context.invitations[0].projectid,
|
|
account: args.context.users[0].account,
|
|
domainid: args.context.users[0].domainid,
|
|
accept: true
|
|
},
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.updateprojectinvitationresponse.jobid,
|
|
getUpdatedItem: function() {
|
|
return {
|
|
state: 'Accepted'
|
|
};
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
messages: {
|
|
confirm: function() {
|
|
return 'message.confirm.join.project';
|
|
},
|
|
notification: function() {
|
|
return 'label.accept.project.invitation';
|
|
}
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
}
|
|
},
|
|
|
|
decline: {
|
|
label: 'label.decline.invitation',
|
|
action: function(args) {
|
|
$.ajax({
|
|
url: createURL('updateProjectInvitation'),
|
|
data: {
|
|
projectid: args.context.invitations[0].projectid,
|
|
account: args.context.users[0].account,
|
|
accept: false
|
|
},
|
|
|
|
success: function(data) {
|
|
args.response.success({
|
|
_custom: {
|
|
jobId: data.updateprojectinvitationresponse.jobid,
|
|
getUpdatedItem: function() {
|
|
return {
|
|
state: 'Declined'
|
|
};
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
},
|
|
notification: {
|
|
poll: pollAsyncJobResult
|
|
},
|
|
messages: {
|
|
confirm: function() {
|
|
return 'message.decline.invitation';
|
|
},
|
|
notification: function() {
|
|
return 'label.decline.invitation';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var projectsActionFilter = function(args) {
|
|
var allowedActions = ['remove', 'edit'];
|
|
|
|
if (args.context.item.account == cloudStack.context.users[0].account ||
|
|
isAdmin() || isDomainAdmin()) {
|
|
if (args.context.item.state == 'Suspended') {
|
|
allowedActions.push('enable');
|
|
} else if (args.context.item.state == 'Active') {
|
|
allowedActions.push('disable');
|
|
}
|
|
|
|
return allowedActions;
|
|
}
|
|
|
|
return [];
|
|
};
|
|
|
|
var projectInvitationActionFilter = function(args) {
|
|
var state = args.context.item.state;
|
|
|
|
if (state == 'Accepted' || state == 'Completed' || state == 'Declined') {
|
|
return [];
|
|
}
|
|
|
|
return ['accept', 'decline'];
|
|
};
|
|
}(cloudStack));
|