public async Task ExecuteAsync(ICommandContext context)
{
IUser targetPlayer = await context.Parameters.GetAsync <IUser>(0);
string groupName = context.Parameters[1];
string permission = "Rocket.Permissions.ManageGroups." + groupName;
IPermissionProvider configPermissions = context.Container.Resolve <IPermissionProvider>("default_permissions");
IPermissionProvider permissions = context.Container.Resolve <IPermissionProvider>();
if (await permissions.CheckPermissionAsync(context.User, permission) != PermissionResult.Grant)
{
throw new NotEnoughPermissionsException(context.User, permission,
"You don't have permissions to manage this group.");
}
IPermissionGroup groupToUpdate = await configPermissions.GetGroupAsync(groupName);
if (groupToUpdate == null)
{
await context.User.SendMessageAsync($"Group \"{groupName}\" was not found.", Color.Red);
return;
}
await UpdateGroup(context.User, configPermissions, targetPlayer, groupToUpdate);
}
public virtual void TestRemovePermissionFromGroup()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = provider.GetGroup("TestGroup2");
Assert.IsTrue(provider.RemovePermission(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Default, provider.CheckPermission(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Default, provider.CheckPermission(TestPlayer, "GroupPermission2"));
}
public virtual async Task TestRemovePermissionFromGroup()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = await provider.GetGroupAsync("TestGroup2");
Assert.IsTrue(await provider.RemovePermissionAsync(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Default, await provider.CheckPermissionAsync(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Default, await provider.CheckPermissionAsync(TestPlayer, "GroupPermission2"));
}
public virtual async Task TestAddPermissionToGroup()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = await provider.GetGroupAsync("TestGroup2");
await provider.AddPermissionAsync(group, "DynamicGroupPermission");
Assert.AreEqual(PermissionResult.Grant, await provider.CheckPermissionAsync(group, "DynamicGroupPermission"));
Assert.AreEqual(PermissionResult.Grant, await provider.CheckPermissionAsync(TestPlayer, "DynamicGroupPermission"));
}
public virtual void TestAddPermissionToGroup()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = provider.GetGroup("TestGroup2");
provider.AddPermission(group, "DynamicGroupPermission");
Assert.AreEqual(PermissionResult.Grant, provider.CheckPermission(group, "DynamicGroupPermission"));
Assert.AreEqual(PermissionResult.Grant, provider.CheckPermission(TestPlayer, "DynamicGroupPermission"));
}
protected override async Task ExecuteUpdateAsync(IPermissionActor target, IPermissionGroup permissionGroup)
{
if (await m_PermissionGroupStore.RemoveGroupFromActorAsync(target, permissionGroup.Id))
{
await Context.Actor.PrintMessageAsync($"Removed \"{target.DisplayName}\" from \"{permissionGroup.DisplayName}\".", Color.DarkGreen);
}
else
{
await Context.Actor.PrintMessageAsync($"Failed to remove \"{target.DisplayName}\" from \"{permissionGroup.DisplayName}\".", Color.DarkRed);
}
}
public bool CreateGroup(IPermissionGroup group)
{
GuardLoaded();
GuardTarget(group);
GroupPermissionSection section = GetConfigSection <GroupPermissionSection>(group, true);
section.Name = group.Name;
section.Priority = group.Priority;
section.Save();
return(true);
}
protected override async Task UpdateGroup(IUser user, IPermissionProvider permissions,
IUser targetUser, IPermissionGroup groupToUpdate)
{
if (await permissions.AddGroupAsync(targetUser, groupToUpdate))
{
await user.SendMessageAsync($"Successfully added {targetUser:Name} to \"{groupToUpdate:Name}\"!",
Color.DarkGreen);
}
else
{
await user.SendMessageAsync($"Failed to add {targetUser:Name} to \"{groupToUpdate:Name}\"!", Color.Red);
}
}
protected override void UpdateGroup(IUser user, IPermissionProvider permissions,
IUserInfo targetUser, IPermissionGroup groupToUpdate)
{
if (permissions.AddGroup(targetUser, groupToUpdate))
{
user.SendMessage($"Successfully added {targetUser:Name} to \"{groupToUpdate:Name}\"!",
Color.DarkGreen);
}
else
{
user.SendMessage($"Failed to add {targetUser:Name} to \"{groupToUpdate:Name}\"!", Color.Red);
}
}
public async Task <bool> CreateGroupAsync(IPermissionGroup group)
{
GuardLoaded();
GuardTarget(group);
GroupPermissionSection section = await GetConfigSectionAsync <GroupPermissionSection>(group, true);
section.Name = group.Name;
section.Priority = group.Priority;
await section.SaveAsync();
return(true);
}
protected override async Task UpdateGroupAsync(IUser user, IPermissionProvider permissions,
IUser targetUser, IPermissionGroup groupToUpdate)
{
if (await permissions.RemoveGroupAsync(targetUser, groupToUpdate))
{
await user.SendMessageAsync($"Successfully removed {targetUser.DisplayName} from \"{groupToUpdate.Name}\"!",
Color.DarkGreen);
}
else
{
await user.SendMessageAsync($"Failed to remove {targetUser.DisplayName} from \"{groupToUpdate.Name}\"!",
Color.Red);
}
}
public virtual void TestHasAllPermissionsGroup()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = provider.GetGroup("TestGroup2");
Assert.AreEqual(PermissionResult.Grant,
provider.CheckHasAllPermissions(group, "GroupPermission2", "GroupPermission2.Child"));
Assert.AreEqual(PermissionResult.Default,
provider.CheckHasAllPermissions(group, "GroupPermission2", "NonExistantPermission"));
//GroupPermission3 is explicitly denied
Assert.AreEqual(PermissionResult.Deny,
provider.CheckHasAllPermissions(group, "GroupPermission2", "GroupPermission3"));
}
public virtual async Task TestHasAllPermissionsGroup()
{
IPermissionChecker checker = LoadChecker();
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = await provider.GetGroupAsync("TestGroup2");
Assert.AreEqual(PermissionResult.Grant,
await checker.CheckHasAllPermissionsAsync(group, "GroupPermission2", "GroupPermission2.Child"));
Assert.AreEqual(PermissionResult.Default,
await checker.CheckHasAllPermissionsAsync(group, "GroupPermission2", "NonExistantPermission"));
//GroupPermission3 is explicitly denied
Assert.AreEqual(PermissionResult.Deny,
await checker.CheckHasAllPermissionsAsync(group, "GroupPermission2", "GroupPermission3"));
}
public virtual void TestGroupPermissions()
{
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = provider.GetGroup("TestGroup2");
Assert.AreEqual(PermissionResult.Default,
provider.CheckPermission(TestPlayer,
"GroupPermission1")); // permission of a group the player doesnt belong to
Assert.AreEqual(PermissionResult.Default, provider.CheckPermission(TestPlayer, "NonExistantPermission"));
Assert.AreEqual(PermissionResult.Grant, provider.CheckPermission(TestPlayer, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Deny, provider.CheckPermission(TestPlayer, "GroupPermission3"));
Assert.AreEqual(PermissionResult.Default, provider.CheckPermission(group, "NonExistantPermission"));
Assert.AreEqual(PermissionResult.Grant, provider.CheckPermission(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Deny, provider.CheckPermission(group, "GroupPermission3"));
}
public bool UpdateGroup(IPermissionGroup group)
{
GuardLoaded();
GuardTarget(group);
GroupPermissionSection section = GetConfigSection <GroupPermissionSection>(group, false);
if (section == null)
{
return(false);
}
section.Name = group.Name;
section.Priority = group.Priority;
section.Save();
return(true);
}
/// <summary>
/// Check if this command is filtered.
/// </summary>
/// <param name="group"></param>
/// <param name="userID"></param>
/// <param name="channelID"></param>
/// <param name="guildID"></param>
/// <param name="roles"></param>
/// <returns></returns>
PermissionStatus IsFiltered(IPermissionGroup group, ulong userID, ulong channelID, ulong guildID, List <SocketRole> roles)
{
PermissionStatus guildStatus = group.IsFiltered(guildID, Enums.PermissionTarget.Guild);
PermissionStatus channelStatus = group.IsFiltered(channelID, Enums.PermissionTarget.Channel);
PermissionStatus userStatus = group.IsFiltered(userID, Enums.PermissionTarget.User);
PermissionStatus roleStatus = PermissionStatus.NotFound;
for (int i = 0; i < roles.Count; i++)
{
SocketRole role = roles[i];
PermissionStatus status = group.IsFiltered(role.Id, Enums.PermissionTarget.Role);
if (status != PermissionStatus.NotFound)
{
roleStatus = status;
if (roleStatus == PermissionStatus.Approved)
{
break;
}
}
}
if (userStatus != PermissionStatus.NotFound)
{
return(userStatus);
}
if (roleStatus != PermissionStatus.NotFound)
{
return(roleStatus);
}
if (channelStatus != PermissionStatus.NotFound)
{
return(channelStatus);
}
if (guildStatus != PermissionStatus.NotFound)
{
return(guildStatus);
}
return(PermissionStatus.NotFound);
}
public virtual async Task TestGroupPermissions()
{
IPermissionChecker checker = LoadChecker();
IPermissionProvider provider = LoadProvider();
IPermissionGroup group = await provider.GetGroupAsync("TestGroup2");
Assert.AreEqual(PermissionResult.Default, await
checker.CheckPermissionAsync(TestPlayer,
"GroupPermission1")); // permission of a group the player doesnt belong to
Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "NonExistantPermission"));
Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Deny, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission3"));
Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(group, "NonExistantPermission"));
Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(group, "GroupPermission2"));
Assert.AreEqual(PermissionResult.Deny, await checker.CheckPermissionAsync(group, "GroupPermission3"));
}
public virtual async Task <bool> UpdateGroupAsync(IPermissionGroup group)
{
if (await GetGroupAsync(group.Id) == null)
{
return(false);
}
var groupData = m_PermissionGroupsDataStore.PermissionGroups.First(d => d.Id.EndsWith(group.Id));
groupData.DisplayName = group.DisplayName;
groupData.IsAutoAssigned = group.IsAutoAssigned;
groupData.Parents = group.Parents;
groupData.Permissions = group.Parents;
groupData.Priority = group.Priority;
groupData.Data ??= new Dictionary <string, object>();
await m_PermissionGroupsDataStore.SaveChangesAsync();
return(true);
}
public bool AddGroup(IIdentity target, IPermissionGroup group)
{
GuardLoaded();
GuardTarget(target);
GuardTarget(group);
PermissionSection section = target is IPermissionGroup
? (PermissionSection)GetConfigSection <GroupPermissionSection>(target, true)
: GetConfigSection <PlayerPermissionSection>(target, true);
List <string> groups = section.GetGroups().ToList();
if (!groups.Any(c => c.Equals(group.Id, StringComparison.OrdinalIgnoreCase)))
{
groups.Add(group.Id);
}
section.SetGroups(groups.ToArray());
section.Save();
return(true);
}
public async Task <bool> AddGroupAsync(IPermissionActor target, IPermissionGroup group)
{
GuardLoaded();
GuardTarget(target);
GuardTarget(group);
PermissionSection section = target is IPermissionGroup
? (PermissionSection) await GetConfigSectionAsync <GroupPermissionSection>(target, true)
: await GetConfigSectionAsync <PlayerPermissionSection>(target, true);
List <string> groups = section.GetGroups().ToList();
if (!groups.Any(c => c.Equals(group.Id, StringComparison.OrdinalIgnoreCase)))
{
groups.Add(group.Id);
}
section.SetGroups(groups.ToArray());
await section.SaveAsync();
return(true);
}
public virtual async Task <bool> CreateGroupAsync(IPermissionGroup group)
{
if (await GetGroupAsync(group.Id) != null)
{
return(false);
}
m_PermissionGroupsDataStore.PermissionGroups.Add(new PermissionGroupData
{
Priority = group.Priority,
Id = group.Id,
DisplayName = group.DisplayName,
Parents = new HashSet <string>(group.Parents, StringComparer.InvariantCultureIgnoreCase),
Permissions = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase),
IsAutoAssigned = group.IsAutoAssigned
});
await m_PermissionGroupsDataStore.SaveChangesAsync();
return(true);
}
public bool RemoveGroup(IIdentity target, IPermissionGroup group)
{
GuardLoaded();
GuardTarget(target);
GuardTarget(group);
PermissionSection section = target is IPermissionGroup
? (PermissionSection)GetConfigSection <GroupPermissionSection>(target, false)
: GetConfigSection <PlayerPermissionSection>(target, false);
if (section == null)
{
return(false);
}
List <string> groups = section.GetGroups().ToList();
int i = groups.RemoveAll(c => c.Equals(group.Id, StringComparison.OrdinalIgnoreCase));
section.SetGroups(groups.ToArray());
section.Save();
return(i > 0);
}
public async Task <bool> RemoveGroupAsync(IPermissionActor target, IPermissionGroup group)
{
GuardLoaded();
GuardTarget(target);
GuardTarget(group);
PermissionSection section = target is IPermissionGroup
? (PermissionSection) await GetConfigSectionAsync <GroupPermissionSection>(target, false)
: await GetConfigSectionAsync <PlayerPermissionSection>(target, false);
if (section == null)
{
return(false);
}
List <string> groups = section.GetGroups().ToList();
int i = groups.RemoveAll(c => c.Equals(group.Id, StringComparison.OrdinalIgnoreCase));
section.SetGroups(groups.ToArray());
await section.SaveAsync();
return(i > 0);
}
public void Execute(ICommandContext context)
{
IUserInfo targetPlayer = context.Parameters.Get <IUserInfo>(0);
string groupName = context.Parameters.Get <string>(1);
string permission = "Rocket.Permissions.ManageGroups." + groupName;
IPermissionProvider permissions = context.Container.Resolve <IPermissionProvider>("default_permissions");
if (permissions.CheckPermission(context.User, permission) != PermissionResult.Grant)
{
throw new NotEnoughPermissionsException(context.User, permission,
"You don't have permissions to manage this group.");
}
IPermissionGroup groupToUpdate = permissions.GetGroup(groupName);
if (groupToUpdate == null)
{
context.User.SendMessage($"Group \"{groupName}\" was not found.", Color.Red);
return;
}
UpdateGroup(context.User, permissions, targetPlayer, groupToUpdate);
}
public async Task <bool> DeleteGroupAsync(IPermissionGroup group)
{
GuardLoaded();
GuardTarget(group);
return(DeleteConfigSection(group));
}
public Task <bool> DeleteGroupAsync(IPermissionGroup group)
=> throw new NotSupportedException("Deleting groups from proxy is not supported.");
public Task <bool> RemoveGroupAsync(IPermissionEntity target, IPermissionGroup group)
=> throw new NotSupportedException("Removing groups from proxy is not supported.");
public bool DeleteGroup(IPermissionGroup group)
{
GuardLoaded();
GuardTarget(group);
return(DeleteConfigSection(group));
}
/// <inheritdoc /> public bool CreateGroup(IPermissionGroup group) => false;
/// <inheritdoc /> public bool DeleteGroup(IPermissionGroup group) => false;
