public async Task <IRole> GetOrCreateDesignatedMuteRoleAsync(IGuild guild, ulong currentUserId)
{
using (var transaction = await DesignatedRoleMappingRepository.BeginCreateTransactionAsync())
{
var mapping = (await DesignatedRoleMappingRepository.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guild.Id,
Type = DesignatedRoleType.ModerationMute,
IsDeleted = false
})).FirstOrDefault();
if (!(mapping is null))
{
return(guild.Roles.First(x => x.Id == mapping.Role.Id));
}
var role = guild.Roles.FirstOrDefault(x => x.Name == MuteRoleName)
?? await guild.CreateRoleAsync(MuteRoleName);
await DesignatedRoleMappingRepository.CreateAsync(new DesignatedRoleMappingCreationData()
{
GuildId = guild.Id,
RoleId = role.Id,
Type = DesignatedRoleType.ModerationMute,
CreatedById = currentUserId
});
transaction.Commit();
return(role);
}
}
/// <inheritdoc />
public async Task AddDesignatedRoleAsync(ulong guildId, ulong roleId, DesignatedRoleType type)
{
AuthorizationService.RequireAuthenticatedUser();
AuthorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingCreate);
using (var transaction = await DesignatedRoleMappingRepository.BeginCreateTransactionAsync())
{
if (await DesignatedRoleMappingRepository.AnyAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guildId,
RoleId = roleId,
Type = type,
IsDeleted = false
}))
{
throw new InvalidOperationException($"Role {roleId} already has a {type} designation");
}
await DesignatedRoleMappingRepository.CreateAsync(new DesignatedRoleMappingCreationData()
{
GuildId = guildId,
RoleId = roleId,
Type = type,
CreatedById = AuthorizationService.CurrentUserId.Value
});
transaction.Commit();
}
}
/// <inheritdoc />
public async Task UnConfigureGuildAsync(IGuild guild)
{
AuthorizationService.RequireAuthenticatedUser();
AuthorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingDelete);
using (var transaction = await DesignatedRoleMappingRepository.BeginDeleteTransactionAsync())
{
foreach (var mapping in await DesignatedRoleMappingRepository
.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guild.Id,
Type = DesignatedRoleType.ModerationMute,
IsDeleted = false,
}))
{
await DesignatedRoleMappingRepository.TryDeleteAsync(mapping.Id, AuthorizationService.CurrentUserId.Value);
var role = guild.Roles.FirstOrDefault(x => x.Id == mapping.Role.Id);
if ((role != null) && (role.Name == MuteRoleName) && (role is IDeletable deletable))
{
await deletable.DeleteAsync();
}
}
transaction.Commit();
}
}
private async Task <IEnumerable <GuildRoleBrief> > GetRankRolesAsync(ulong guildId)
=> (await DesignatedRoleMappingRepository
.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria
{
GuildId = guildId,
Type = DesignatedRoleType.Rank,
IsDeleted = false,
}))
.Select(r => r.Role);
private async Task <IEnumerable <GuildRoleBrief> > GetRankRolesAsync()
=> (await DesignatedRoleMappingRepository
.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria
{
GuildId = AuthorizationService.CurrentGuildId,
Type = DesignatedRoleType.Rank,
IsDeleted = false,
}))
.Select(r => r.Role);
/// <inheritdoc />
public Task <IReadOnlyCollection <DesignatedRoleMappingBrief> > GetDesignatedRolesAsync(ulong guildId)
{
AuthorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingRead);
return(DesignatedRoleMappingRepository.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guildId,
IsDeleted = false
}));
}
public Task <bool> RolesHaveDesignationAsync(
ulong guildId,
IReadOnlyCollection <ulong> roleIds,
DesignatedRoleType designation,
CancellationToken cancellationToken)
=> DesignatedRoleMappingRepository.AnyAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guildId,
RoleIds = roleIds,
IsDeleted = false,
Type = designation
}, default);
public Task <bool> RoleHasDesignationAsync(
ulong guildId,
ulong roleId,
DesignatedRoleType designation,
CancellationToken cancellationToken)
=> DesignatedRoleMappingRepository.AnyAsync(new DesignatedRoleMappingSearchCriteria
{
GuildId = guildId,
RoleId = roleId,
IsDeleted = false,
Type = designation
}, default);
private static (ModixContext, DesignatedRoleMappingRepository) BuildTestContext()
{
var modixContext = TestDataContextFactory.BuildTestDataContext(x =>
{
x.Set <UserEntity>().AddRange(Users.Entities.Clone());
x.Set <GuildUserEntity>().AddRange(GuildUsers.Entities.Clone());
x.Set <GuildRoleEntity>().AddRange(GuildRoles.Entities.Clone());
x.Set <DesignatedRoleMappingEntity>().AddRange(DesignatedRoleMappings.Entities.Clone());
x.Set <ConfigurationActionEntity>().AddRange(ConfigurationActions.Entities.Where(y => !(y.DesignatedRoleMappingId is null)).Clone());
});
var uut = new DesignatedRoleMappingRepository(modixContext);
return(modixContext, uut);
}
private async Task <IRole> GetDesignatedMuteRoleAsync(IGuild guild)
{
var mapping = (await DesignatedRoleMappingRepository.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guild.Id,
Type = DesignatedRoleType.ModerationMute,
IsDeleted = false
})).FirstOrDefault();
if (mapping == null)
{
throw new InvalidOperationException($"There are currently no designated mute roles within guild {guild.Id}");
}
return(guild.Roles.First(x => x.Id == mapping.Role.Id));
}
/// <inheritdoc />
public async Task RemoveDesignatedRoleByIdAsync(long id)
{
AuthorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingDelete);
using (var transaction = await DesignatedRoleMappingRepository.BeginDeleteTransactionAsync())
{
var deletedCount = await DesignatedRoleMappingRepository.DeleteAsync(new DesignatedRoleMappingSearchCriteria()
{
Id = id,
IsDeleted = false
}, AuthorizationService.CurrentUserId.Value);
if (deletedCount == 0)
{
throw new InvalidOperationException($"No role assignment exists with id {id}");
}
transaction.Commit();
}
}
/// <inheritdoc />
public async Task RemoveDesignatedRoleAsync(ulong guildId, ulong roleId, DesignatedRoleType type)
{
AuthorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingDelete);
using (var transaction = await DesignatedRoleMappingRepository.BeginDeleteTransactionAsync())
{
var deletedCount = await DesignatedRoleMappingRepository.DeleteAsync(new DesignatedRoleMappingSearchCriteria()
{
GuildId = guildId,
RoleId = roleId,
Type = type,
IsDeleted = false
}, AuthorizationService.CurrentUserId.Value);
if (deletedCount == 0)
{
throw new InvalidOperationException($"Role {roleId} does not have a {type} designation");
}
transaction.Commit();
}
}
private async Task SetUpMentionableRoles(IGuild guild)
{
var mentionableRoleMappings = await DesignatedRoleMappingRepository.SearchBriefsAsync(new DesignatedRoleMappingSearchCriteria
{
GuildId = guild.Id,
Type = DesignatedRoleType.RestrictedMentionability,
IsDeleted = false
});
Log.Information("Roles with RestrictedMentionability are: {Roles}", mentionableRoleMappings.Select(d => d.Role.Name));
//Get the actual roles that correspond to our mappings
var mentionableRoles = mentionableRoleMappings
.Join(guild.Roles, d => d.Role.Id, d => d.Id, (map, role) => role)
.Where(d => d.IsMentionable);
try
{
//Ensure all roles with restricted mentionability are not mentionable
foreach (var role in mentionableRoles)
{
Log.Information("Role @{Role} has RestrictedMentionability but was marked as Mentionable.", role.Name);
await role.ModifyAsync(d => d.Mentionable = false);
Log.Information("Role @{Role} was set to unmentionable.", role.Name);
}
}
catch (HttpException ex)
{
var errorTemplate = "An exception was thrown when attempting to set up mention-restricted roles for {Guild}. " +
"This is likely due to Modix not having the \"Manage Roles\" permission, or Modix's role being below one of " +
"the mention-restricted roles in your server's Role list - please check your server settings.";
Log.Error(ex, errorTemplate, guild.Name);
}
}
/// <inheritdoc /> public Task <IReadOnlyCollection <DesignatedRoleMappingBrief> > SearchDesignatedRolesAsync(DesignatedRoleMappingSearchCriteria searchCriteria) => DesignatedRoleMappingRepository.SearchBriefsAsync(searchCriteria);
