private async Task TryCheckMessageAsync(IMessage message)
{
if (!(message.Author is IGuildUser author) ||
(author.Guild is null) ||
!(message.Channel is IGuildChannel channel) ||
(channel.Guild is null))
{
Log.Debug(
"Message {MessageId} was not in an IGuildChannel & IMessageChannel, or Author {Author} was not an IGuildUser",
message.Id, message.Author.Id);
return;
}
if (author.Id == _discordSocketClient.CurrentUser.Id)
{
return;
}
var isContentBlocked = await IsContentBlocked(channel, message);
if (!isContentBlocked)
{
return;
}
if (await _designatedChannelService.ChannelHasDesignationAsync(channel.Guild,
channel, DesignatedChannelType.Unmoderated, default))
{
return;
}
if (await _authorizationService.HasClaimsAsync(author, AuthorizationClaim.BypassMessageContentPatternCheck))
{
Log.Debug("Message {MessageId} was skipped because the author {Author} has the {Claim} claim",
message.Id, message.Author.Id, AuthorizationClaim.BypassMessageContentPatternCheck);
return;
}
Log.Debug("Message {MessageId} is going to be deleted", message.Id);
await _moderationService.DeleteMessageAsync(message, "Unauthorized Message Content",
_discordSocketClient.CurrentUser.Id, default);
Log.Debug("Message {MessageId} was deleted because it contains blocked content", message.Id);
await message.Channel.SendMessageAsync(
$"Sorry {author.Mention} your message contained blocked content and has been removed!");
}
private async Task HandleReactionAsync(ICacheable <IUserMessage, ulong> cachedMessage, IReaction reaction)
{
var emote = reaction.Emote;
if (!_starboardService.IsStarEmote(emote))
{
return;
}
var message = await cachedMessage.GetOrDownloadAsync();
if (!(message.Channel is IGuildChannel channel))
{
return;
}
var isIgnoredFromStarboard = await _designatedChannelService
.ChannelHasDesignationAsync(channel.Guild, channel, DesignatedChannelType.IgnoredFromStarboard);
var starboardExists = await _designatedChannelService
.AnyDesignatedChannelAsync(channel.GuildId, DesignatedChannelType.Starboard);
if (isIgnoredFromStarboard || !starboardExists)
{
return;
}
var reactionCount = await _starboardService.GetReactionCount(message, emote);
if (await _starboardService.ExistsOnStarboard(message))
{
if (_starboardService.IsAboveReactionThreshold(reactionCount))
{
await _starboardService.ModifyEntry(channel.Guild, message, FormatContent(reactionCount), GetEmbedColor(reactionCount));
}
else
{
await _starboardService.RemoveFromStarboard(channel.Guild, message);
}
}
else if (_starboardService.IsAboveReactionThreshold(reactionCount))
{
var embed = GetStarEmbed(message, GetEmbedColor(reactionCount));
await _starboardService.AddToStarboard(channel.Guild, message, FormatContent(reactionCount), embed);
}
}
public async Task AutoConfigureChannelAsync(IChannel channel)
{
_authorizationService.RequireAuthenticatedUser();
_authorizationService.RequireClaims(AuthorizationClaim.DesignatedRoleMappingCreate);
if (channel is IGuildChannel guildChannel)
{
var isUnmoderated = await _designatedChannelService.ChannelHasDesignationAsync(guildChannel.Guild.Id,
channel.Id, DesignatedChannelType.Unmoderated, default);
if (isUnmoderated)
{
return;
}
var muteRole =
await GetOrCreateDesignatedMuteRoleAsync(guildChannel.Guild,
_authorizationService.CurrentUserId.Value);
await ConfigureChannelMuteRolePermissionsAsync(guildChannel, muteRole);
}
}
/// <summary>
/// Determines whether or not to skip a message event, based on unmoderated channel designations
/// </summary>
/// <param name="guild">The guild designations should be looked up for</param>
/// <param name="channel">The channel designations should be looked up for</param>
/// <returns>True if the channel is designated as Unmoderated, false if not</returns>
private async Task <bool> IsChannelModeratedAsync(IGuild guild, IMessageChannel channel)
{
return(await _designatedChannelService.ChannelHasDesignationAsync(guild, channel, DesignatedChannelType.Unmoderated));
}
private async Task TryCheckMessageAsync(IPartialMessage message, CancellationToken ct = default)
{
var channelId = message.ChannelID.Value;
var isThreadChannel = await _threadSvc.IsThreadChannelAsync(channelId, ct);
if (!isThreadChannel)
{
return;
}
if (!message.GuildID.HasValue)
{
return;
}
if (!message.Author.HasValue)
{
return;
}
var author = message.Author.Value;
var authorId = author.ID;
var messageId = message.ID.Value;
var guildId = message.GuildID.Value;
if ((author.IsBot.HasValue && author.IsBot.Value) ||
(author.IsSystem.HasValue && author.IsSystem.Value))
{
return;
}
if (!message.Content.HasValue)
{
return;
}
var isContentBlocked = await IsContentBlockedAsync(message);
if (!isContentBlocked)
{
return;
}
if (await _designatedChannelService.ChannelHasDesignationAsync(guildId.Value, channelId.Value, DesignatedChannelType.Unmoderated, default))
{
return;
}
var roles = message.Member.Value.Roles.Value.Select(a => a.Value).ToList();
roles.Add(guildId.Value);
await _remoraAuthService.SetCurrentAuthenticatedUserAsync(guildId, authorId);
if (await _authService.HasClaimsAsync(authorId.Value, messageId.Value, roles, AuthorizationClaim.BypassMessageContentPatternCheck))
{
Log.Debug("Message {MessageId} was skipped because the author {Author} has the {Claim} claim",
messageId, authorId, AuthorizationClaim.BypassMessageContentPatternCheck);
return;
}
Log.Debug("Message {MessageId} is going to be deleted", message.ID);
using var transaction = await _deletedMessageRepository.BeginCreateTransactionAsync(ct);
var reason = "Unauthorized Message Content";
await _channelApi.DeleteMessageAsync(channelId, messageId, reason, ct);
var self = await _userApi.GetCurrentUserAsync(ct);
await _deletedMessageRepository.CreateAsync(
new DeletedMessageCreationData()
{
GuildId = guildId.Value,
ChannelId = channelId.Value,
MessageId = messageId.Value,
AuthorId = authorId.Value,
Content = message.Content.Value,
Reason = reason,
CreatedById = self.Entity !.ID.Value
}, ct);
