mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
1148 lines
37 KiB
JavaScript
1148 lines
37 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 != 8;
|
|
}
|
|
);
|
|
|
|
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'
|
|
}
|
|
};
|
|
|
|
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 data = {
|
|
accountId: user.userid,
|
|
listAll: true
|
|
};
|
|
|
|
if (args.projectName) {
|
|
data.keyword = args.projectName;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listProjects', { ignoreProject: true }),
|
|
data: data,
|
|
dataType: 'json',
|
|
async: true,
|
|
success: function(data) {
|
|
args.response.success({
|
|
data: $.map(
|
|
data.listprojectsresponse.project ?
|
|
data.listprojectsresponse.project : [],
|
|
function(elem) {
|
|
return $.extend(elem, {
|
|
displayText: elem.displaytext
|
|
});
|
|
})
|
|
});
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
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: '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});
|
|
}
|
|
}
|
|
args.response.success({
|
|
data: array1
|
|
});
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
args.response.success({
|
|
data: null
|
|
});
|
|
}
|
|
},
|
|
isHidden: function(args) {
|
|
if(isAdmin() || isDomainAdmin())
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
},
|
|
|
|
account: {
|
|
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
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
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' });
|
|
},
|
|
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 },
|
|
domain: { label: 'label.domain' },
|
|
account: { label: 'label.account'},
|
|
state: { label: 'label.state' }
|
|
}
|
|
],
|
|
|
|
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));
|