/// <summary>
/// Consumes a message, adding it to the active roleplay in its channel if the author is a participant.
/// </summary>
/// <param name="message">The received message.</param>
/// <param name="guildID">The ID of the guild in which the message was received.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task <Result> ConsumeMessageAsync(IPartialMessage message, Snowflake guildID)
{
if (!message.ID.HasValue)
{
return(new InvalidOperationError("Unable to process messages without IDs."));
}
if (!message.Timestamp.HasValue)
{
return(new InvalidOperationError("Unable to process messages without timestamps."));
}
if (!message.Content.HasValue)
{
return(new InvalidOperationError("Unable to process messages without content."));
}
if (!message.ChannelID.HasValue)
{
return(new InvalidOperationError("Unable to process messages without channel IDs."));
}
if (!message.Author.HasValue)
{
return(new InvalidOperationError("Unable to process messages without authors."));
}
var hasActive = await HasActiveRoleplayAsync(message.ChannelID.Value);
if (!hasActive.IsSuccess)
{
return(Result.FromError(hasActive));
}
if (!hasActive.Entity)
{
return(Result.FromSuccess());
}
var result = await GetActiveRoleplayAsync(message.ChannelID.Value);
if (!result.IsSuccess)
{
return(Result.FromError(result));
}
var roleplay = result.Entity;
if (!roleplay.HasJoined(message.Author.Value))
{
return(new UserError("The given message was not authored by a participant of the roleplay."));
}
var userNick = message.Author.Value.Username;
var getMember = await _guildAPI.GetGuildMemberAsync(guildID, message.Author.Value.ID);
if (getMember.IsSuccess)
{
var member = getMember.Entity;
if (member.Nickname.HasValue && member.Nickname.Value is not null)
{
userNick = member.Nickname.Value;
}
}
var getAuthor = await _users.GetOrRegisterUserAsync(message.Author.Value.ID);
if (!getAuthor.IsSuccess)
{
return(Result.FromError(getAuthor));
}
var author = getAuthor.Entity;
return(await _roleplays.AddOrUpdateMessageInRoleplayAsync
(
roleplay,
author,
message.ID.Value,
message.Timestamp.Value,
userNick,
message.Content.Value
));
}
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);
