public async Task AddBindingsAsync(ulong channelId, ulong messageId, string emoji, HashSet <ulong> roleIds)
{
List <RoleBinding> bindingsToAdd = new();
foreach (ulong roleId in roleIds)
{
RoleBinding binding = new()
{
ChannelId = channelId, MessageId = messageId, Emoji = emoji, RoleId = roleId
};
if (await _dbContext.RoleBindings.AnyAsync(db => db.Emoji == binding.Emoji &&
db.ChannelId == binding.ChannelId &&
db.MessageId == binding.MessageId &&
db.RoleId == binding.RoleId))
{
_logger.LogInformation("Binding for this combination already exists (roleId: {RoleId})", roleId);
continue;
}
bindingsToAdd.Add(binding);
}
await _dbContext.RoleBindings.AddRangeAsync(bindingsToAdd);
await _dbContext.SaveChangesAsync();
}
public async Task IncrementAsync(ulong emojiId)
{
var emoji = await _dbContext.CountedEmojis.FindAsync(emojiId);
if (emoji == null)
{
emoji = new Database.CountedEmoji()
{
Id = emojiId
};
await _dbContext.CountedEmojis.AddAsync(emoji);
}
emoji.Times++;
await _dbContext.SaveChangesAsync();
}
public async Task <bool> DeleteWarningAsync(int id)
{
Database.Warning?warning = await _dbContext.Warnings.FirstOrDefaultAsync(w => w.Id == id);
if (warning == null)
{
return(false);
}
_dbContext.Warnings.Remove(warning);
try
{
await _dbContext.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(e, "Couldn't remove warning {@Warning}", warning);
return(false);
}
return(true);
}
private async Task EraseMemberAsync(CommandContext ctx, Verification?databaseRecord, string userName)
{
await ctx.TriggerTypingAsync();
if (databaseRecord == null)
{
await ctx.Channel.SendMessageAsync("No member record to erase.");
return;
}
DiscordEmoji emoji = DiscordEmoji.FromName(ctx.Client, ":ok_hand:");
DiscordMessage reactMessage =
await ctx.Channel.SendMessageAsync($"To approve erase of `{userName}`, react with {emoji}");
await reactMessage.CreateReactionAsync(emoji);
InteractivityResult <MessageReactionAddEventArgs> result =
await reactMessage.WaitForReactionAsync(ctx.Member, emoji);
await ctx.TriggerTypingAsync();
if (result.TimedOut)
{
await ctx.Channel.SendMessageAsync("Member hasn't been erased due to approval timeout.");
return;
}
try
{
_dbContext.Verifications.Remove(databaseRecord);
await _dbContext.SaveChangesAsync();
await ctx.Channel.SendMessageAsync("Member has been erased.");
}
catch (Exception e)
{
await ctx.Channel.SendMessageAsync("Member erase failed.");
_logger.LogWarning(e, "Member erase failed");
}
}
public async Task <IAuthorizationService.AuthorizeResult> AuthorizeAsync(string accessToken, string username, ulong userId, RolesPool rolesPool)
{
bool discordIdPresent = await IsUserVerified(userId);
UsermapPerson?person = await _usermapInfoService.GetUserInfoAsync(accessToken, username);
if (person == null)
{
_logger.LogWarning("Couldn't fetch info from UserMap");
return(IAuthorizationService.AuthorizeResult.UserMapError);
}
string authId = _hashService.Hash(person.Username);
bool authPresent = await _dbContext.Verifications.AnyAsync(v => v.AuthId == authId);
IReadOnlySet <DiscordRole> discordRoles = _roleManager.MapUsermapRoles(person.Roles, rolesPool);
// discord and auth -> update roles
if (discordIdPresent && authPresent)
{
bool verificationExists =
await _dbContext.Verifications.AnyAsync(v => v.UserId == userId && v.AuthId == authId);
if (verificationExists)
{
bool ungranted = await _roleManager.RevokeRolesPoolAsync(userId, rolesPool);
if (!ungranted)
{
_logger.LogWarning("Ungranting roles pool {2} for {0} (id {1}) failed.", username, userId, rolesPool);
return(IAuthorizationService.AuthorizeResult.Failed);
}
bool granted = await _roleManager.GrantRolesAsync(userId, discordRoles);
return(granted ? IAuthorizationService.AuthorizeResult.OK : IAuthorizationService.AuthorizeResult.Failed);
}
return(IAuthorizationService.AuthorizeResult.DifferentMember);
}
// discord xor auth -> user already verified, error
if (discordIdPresent || authPresent)
{
return(IAuthorizationService.AuthorizeResult.DifferentMember);
}
// nothing -> create database entry, update roles
{
bool rolesGranted = await _roleManager.GrantRolesAsync(userId, discordRoles);
if (rolesGranted)
{
Verification verification = new() { AuthId = authId, UserId = userId };
await _dbContext.Verifications.AddAsync(verification);
await _dbContext.SaveChangesAsync();
await _roleManager.RevokeHostRolesAsync(userId);
return(IAuthorizationService.AuthorizeResult.OK);
}
return(IAuthorizationService.AuthorizeResult.Failed);
}
}