public void Enrich(Scope scope, DiscordClient shard, MessageDeleteEventArgs evt)
{
scope.AddBreadcrumb("", "event.messageDelete",
data: new Dictionary<string, string>()
{
{"channel", evt.Channel.Id.ToString()},
{"guild", evt.Channel.GuildId.ToString()},
{"message", evt.Message.Id.ToString()},
});
scope.SetTag("shard", shard.ShardId.ToString());
}
public static async Task LevelsClient_MessageDeleted(DiscordClient sender, MessageDeleteEventArgs messageDeleteEventArgs)
{
if (!LevelOptions.RemoveExpOnMessageDelete)
{
return;
}
if (messageDeleteEventArgs.Message.Author.IsBot)
{
return;
}
await DatabaseActions.RevokeExp(messageDeleteEventArgs.Message.Author.Id.ToString());
}
private static DiscordMessage RemoveMessageFromStorage(MessageDeleteEventArgs e, Dictionary <ulong, DiscordMessage> t)
{
DiscordMessage m;
t.TryGetValue(e.Message.Id, out m);
if (m != null)
{
t.Remove(e.Message.Id);
}
return(m);
}
public static async Task MessageDeleted(MessageDeleteEventArgs args)
{
DiscordEmbedBuilder embed = new DiscordEmbedBuilder();
DiscordChannel logChannel = args.Guild.GetChannelByName("tux-logs");
await logChannel.TriggerTypingAsync().ConfigureAwait(false);
embed.Title = "Message Deleted";
embed.AddField("Message", args.Message.Content);
embed.AddField("Author", args.Message.Author.Mention, true);
embed.AddField("Channel", args.Channel.Mention, true);
embed.Color = ColorUtils.GetRandomColor();
await logChannel.SendMessageAsync(embed : embed).ConfigureAwait(false);
}
/// <summary>
/// Отлавливаем удаленные сообщения и отправляем в лог
/// </summary>
private Task ClientOnMessageDeleted(MessageDeleteEventArgs e)
{
if (!GetMultiplySettingsSeparated(BotSettings.IgnoredChannels).Contains(e.Channel.Id)) // в лог не должны отправляться сообщения,
// удаленные из лога
{
e.Guild.GetChannel(BotSettings.FulllogChannel)
.SendMessageAsync($"**Удаление сообщения**\n" +
$"**Автор:** {e.Message.Author.Username}#{e.Message.Author.Discriminator} ({e.Message.Author.Id})\n" +
$"**Канал:** {e.Channel}\n" +
$"**Содержимое: ```{e.Message.Content}```**");
}
return(Task.CompletedTask);
}
private async Task MessageLogger(MessageDeleteEventArgs e)
{
var channelId = e.Guild.Channels.FirstOrDefault(x => x.Value.Name == "message-log").Key;
if (channelId != 0)
{
var channel = e.Guild.Channels[channelId];
var embed = CreateLogEmbed(e.Message).Result;
embed.WithDescription($"🗑 **Message deleted in {e.Message.Channel.Mention}**");
await channel.SendMessageAsync(embed : embed);
}
}
internal static Task MessageDeleted(DiscordClient _1, MessageDeleteEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.Guild.Id != 699555747591094344)
{
return;
}
if (e.Channel.Id == 722905404354592900 || e.Channel.Id == 700009728151126036)
{
return;
}
if (e.Message.Content is null)
{
return;
}
DiscordEmbedBuilder embed = new DiscordEmbedBuilder()
.WithTimestamp(DateTime.Now)
.WithDescription($"Message created by {e.Message.Author.Mention} ({e.Message.Author.Id}) was deleted in {e.Channel.Mention}\n" +
$"Message ID: {e.Message.Id}\n\n" +
e.Message.Content)
.WithThumbnail(e.Message.Author.AvatarUrl)
.WithColor(DiscordColor.Red);
var message = new DiscordMessageBuilder();
Dictionary <string, Stream> attachments = new Dictionary <string, Stream>();
if (!(e.Message.Attachments is null) && e.Message.Attachments.Any())
{
foreach (var attachment in e.Message.Attachments)
{
attachments.Add(attachment.FileName, WebRequest.Create(attachment.Url).GetResponse().GetResponseStream());
if (attachment.MediaType.Contains("image") && string.IsNullOrEmpty(embed.ImageUrl))
{
embed.WithImageUrl("attachment://" + attachment.FileName);
}
}
message.WithFiles(attachments);
}
await DiscordObjectService.Instance.LogsChannel.SendMessageAsync(message.WithEmbed(embed).WithAllowedMentions(Mentions.None));
foreach (var attachment in attachments)
{
attachment.Value.Close();
}
});
return(Task.CompletedTask);
}
public static async Task MessageSniped(ModCoreShard bot, MessageDeleteEventArgs e)
{
await Task.Yield();
if ((!string.IsNullOrEmpty(e.Message.Content) || e.Message.Embeds.Count > 0) && !e.Message.Author.IsBot)
{
if (bot.SharedData.DeletedMessages.ContainsKey(e.Channel.Id))
{
bot.SharedData.DeletedMessages[e.Channel.Id] = e.Message;
}
else
{
bot.SharedData.DeletedMessages.TryAdd(e.Channel.Id, e.Message);
}
}
}
public static Task OnMessageDeleted(DiscordClient _, MessageDeleteEventArgs args)
{
if (args.Channel.IsPrivate)
{
return(Task.CompletedTask);
}
if (!MessageQueue.TryGetValue(args.Channel.Id, out var queue))
{
return(Task.CompletedTask);
}
lock (queue.syncObj)
queue.Evict(args.Message.Id);
return(Task.CompletedTask);
}
public static async Task MessageBeenDeleted(DiscordClient _, MessageDeleteEventArgs e)
{
var data = new Global().GetDBRecords(e.Guild.Id);
var channelId = Convert.ToUInt64(data.LogChannel);
var embed1 = new DiscordEmbedBuilder()
.WithAuthor($"{e.Message.Author.FullDiscordName()} Deleted a message!",
icon_url: e.Message.Author.AvatarUrl)
.WithColor(DiscordColor.IndianRed)
.WithDescription($"**Channel message deleted in:** {e.Channel.Mention}\n" +
$"**Time Message Created:** {e.Message.CreationTimestamp.ToLocalTime():hh:mm:ss tt} on {e.Message.CreationTimestamp.LocalDateTime.DayOfWeek}\n" +
$"**Time Message Deleted:** {DateTime.Now.ToLocalTime():hh:mm:ss tt} on {DateTime.Now.ToLocalTime().DayOfWeek}")
.AddField("Message", $"{$"-{e.Message.Content.Truncate(250)}".BlockCode_DIFF()}");
await e.Guild.GetChannel(channelId).SendMessageAsync(embed: embed1);
}
async Task OnReceiveDiscordDeleteLog(MessageDeleteEventArgs e)
{
if (e.Message.Channel?.Name == "logs" || (e.Message.Author?.IsBot ?? true))
{
return;
}
int ind = -1;
if ((ind = FindIndexOfIdInCache(e.Message.Id)) != -1)
{
await NotifyDeleteAsync(discordMessageCache[ind], e.Guild);
discordMessageCache[ind] = null;
}
else
{
await NotifyDeleteAsync(e.Message, e.Guild);
}
}
private void MessageDelete(BaseDiscordClient client, Embed embed, MessageDeleteEventArgs messageDeleteEventArgs)
{
this.logger.Information(!string.IsNullOrWhiteSpace(messageDeleteEventArgs.Message.Content)
? $"The message ({messageDeleteEventArgs.Message.Id}) from '{messageDeleteEventArgs.Message.Author.GetUsertag()}' ({messageDeleteEventArgs.Message.Author.Id}) was deleted in '{messageDeleteEventArgs.Channel.Name}' ({messageDeleteEventArgs.Channel.Id}) on '{messageDeleteEventArgs.Guild.Name}' ({messageDeleteEventArgs.Guild.Id})."
: $"The message ({messageDeleteEventArgs.Message.Id}) was deleted in '{messageDeleteEventArgs.Channel.Name}' ({messageDeleteEventArgs.Channel.Id}) on '{messageDeleteEventArgs.Guild.Name}' ({messageDeleteEventArgs.Guild.Id}).");
var thumbnailUrl = string.Empty;
var fields = new List <EmbedField>
{
new EmbedField
{
Inline = false,
Name = "Content"
}
};
if (messageDeleteEventArgs.Message != null)
{
thumbnailUrl = messageDeleteEventArgs.Message.Author.AvatarUrl;
fields.First()
.Value = messageDeleteEventArgs.Message.Content;
embed.Footer = new EmbedFooter {
Text = $"Author: {messageDeleteEventArgs.Message.Author.Id} | Message Id: {messageDeleteEventArgs.Message.Id}"
};
}
else
{
fields.First()
.Value = "The value is not available due to the message was send while the bot were offline or it's no longer in the cache.";
embed.Footer = new EmbedFooter {
Text = $"Message Id: {messageDeleteEventArgs.Message.Id}"
};
}
embed.Title = $"{DiscordEmoji.FromGuildEmote(client, EmojiLibrary.Erase)} Message deleted";
embed.Description = new StringBuilder().AppendLine($"Message ({messageDeleteEventArgs.Message.Id}) deleted in {messageDeleteEventArgs.Channel.Mention}.")
.ToString();
embed.Color = DiscordColor.IndianRed;
embed.Thumbnail = thumbnailUrl;
embed.Fields = fields;
}
public static async Task JanitorDeleteHandler(MessageDeleteEventArgs e)
{
if (e.Channel.Name == "trade" || e.Channel.Name == "searching-players")
{
var embed = new DiscordEmbedBuilder()
{
Description = e.Message.Content,
Timestamp = e.Message.Timestamp,
Color = DiscordColor.Red
};
embed.WithAuthor($"{e.Message.Author.Username}#{e.Message.Author.Discriminator} in #{e.Channel.Name}", null, e.Message.Author.AvatarUrl);
var channel = e.Guild.Channels.FirstOrDefault(c => c.Name == "broomcloset");
if (channel == null)
{
return;
}
await channel.SendMessageAsync("", false, embed.Build());
}
}
private async Task ClientOnMessageDeleted(MessageDeleteEventArgs args)
{
if (args.Channel.IsPrivate)
{
return;
}
using (var db = new LiteDatabase("Data.db"))
{
var rms = db.GetCollection <ReactionMessage>();
var rm = rms.FindOne(x =>
x.GuildId == args.Channel.Guild.Id &&
x.ChannelId == args.Channel.Id &&
x.MessageId == args.Message.Id);
if (rm is null)
{
return;
}
rms.Delete(rm.DbId);
}
}
private async Task ManageDeletedMessage(DiscordClient sender, MessageDeleteEventArgs e)
{
Dictionary <ulong, DiscordMessage>?t = null;
this.TryGetValue(e.Guild.Id, out t);
if (t == null)
{
await SnipeWhereNull(sender, e);
}
t.TryAdd(e.Message.Id, e.Message);
await Task.Delay(TimeSpan.FromSeconds(30));
DiscordMessage?m;
this.TryGetValue(e.Guild.Id, out t);
if (t != null)
{
m = RemoveMessageFromStorage(e, t);
}
}
public static Task MessageDeleted(MessageDeleteEventArgs e)
{
/* AUTHOR CHECK */
if (!e.Message.Author.IsBot && e.Message.Author != e.Client.CurrentUser)
{
/* MESSAGE TYPE CHECK */
if (e.Message.MessageType == MessageType.Default)
{
switch (e.Message.Channel.Type)
{
case DSharpPlus.ChannelType.Private:
Console.ForegroundColor = ConsoleColor.DarkRed;
Logger.Write($"[Removed] ");
Console.ForegroundColor = ConsoleColor.Magenta;
Logger.Write($"[DMs] ");
Console.ForegroundColor = ConsoleColor.Green;
Logger.Write($"[{DateTime.Now}] ");
Console.ForegroundColor = ConsoleColor.Yellow;
Logger.Write($"{e.Message.Author.Username}#{e.Message.Author.Discriminator} ({e.Message.Author.Id}) | ");
Console.ForegroundColor = ConsoleColor.Magenta;
Logger.WriteLine($"{e.Message.Content}");
Console.ResetColor();
break;
case DSharpPlus.ChannelType.Group:
Console.ForegroundColor = ConsoleColor.DarkRed;
Logger.Write($"[Removed] ");
Console.ForegroundColor = ConsoleColor.Blue;
Logger.Write($"[Group ({e.Message.Channel.Name})] ");
Console.ForegroundColor = ConsoleColor.Green;
Logger.Write($"[{DateTime.Now}] ");
Console.ForegroundColor = ConsoleColor.Yellow;
Logger.Write($"{e.Message.Author.Username}#{e.Message.Author.Discriminator} ({e.Message.Author.Id}) | ");
Console.ForegroundColor = ConsoleColor.Magenta;
Logger.WriteLine($"{e.Message.Content}");
break;
}
}
}
return(Task.CompletedTask);
}
internal static async Task BotClientMessageDeleted(MessageDeleteEventArgs e)
{
if (e.Channel.Id == Program.Settings.RimboardChannelId)
{
// Be warned: OriginalReactCount is always equal to -1.
PinInfo pinInfo = await QueryPinInfoFromRimboardId(e.Message.Id);
if (!pinInfo.Equals(PinInfo.Invalid))
{
// Get the channels.
DiscordChannel originalChannel = e.Guild.GetChannel(pinInfo.OriginalChannelId);
DiscordMessage originalMessage = await originalChannel.GetMessageAsync(pinInfo.OriginalMessageId);
var a = originalMessage.DeleteAllReactionsAsync();
var b = RemovePinFromDatabase(pinInfo);
await Task.WhenAll(a, b);
}
}
}
public static Task MsgLogger(MessageDeleteEventArgs e)
{
MsgClass msg = new MsgClass();
if (e.Message.Content != null)
{
try
{
try
{
Console.WriteLine("Channel: " + e.Message.Channel.Name + " | " + e.Message.Channel.Guild.Name);
msg.channel = e.Message.Channel.Name;
msg.server = e.Message.Channel.Guild.Name;
}
catch { } //Exception appears when hanled direct message
try
{
Console.WriteLine("By: " + e.Message.Author.Username);
msg.Author = e.Message.Author.Username;
}
//Some wierd bug when author name is null
catch { Console.WriteLine("Author name error(null)"); }
Console.WriteLine("Message: " + e.Message.Content);
msg.message = e.Message.Content;
Console.WriteLine("At: " + e.Message.CreationTimestamp.UtcDateTime.ToString() + " - " + DateTime.Now.ToString());
msg.C_time = e.Message.CreationTimestamp.UtcDateTime; msg.R_time = DateTime.Today;
if (e.Message.MentionedUsers.Contains(client.CurrentUser))
{
Console.WriteLine("Mentioned!"); msg.mentioned = true;
}
}
catch (Exception excp) { Console.WriteLine("ERR: " + excp.Message); }
File.AppendAllText("./Log.json", JsonConvert.SerializeObject(msg) + Environment.NewLine);
Console.WriteLine("-------------END MESSAGE--------------");
}
return(Task.CompletedTask);
}
private Task OnMessageDeleted(MessageDeleteEventArgs e)
{
if (Guild == null || Channel == null || e.Message.Channel.Id != Channel.Id)
{
return(Task.CompletedTask);
}
var message = e.Message;
for (int i = 0; i < Output_ChatText.Items.Count; i++)
{
if (i == 100 || GetID(Output_ChatText.Items[i].ToString()) != message.Id)
{
continue;
}
Output_ChatText.Items[i] = Output_ChatText.Items[i].ToString().Substring(0, Output_ChatText.Items[i].ToString().LastIndexOf("[") - 1); // delete everything past the message's body
Output_ChatText.Items[i] += " {MESSAGE DELETED} []"; // and add a note that it's deleted
}
return(Task.CompletedTask);
}
private static async Task MessageDeleteLogger(MessageDeleteEventArgs e)
{
if (e.Channel.ParentId == 693523162729545768 || e.Channel.ParentId == 693523249237196821)
{
return;
}
if (e.Message.Content.StartsWith("i.t") || e.Message.Content.StartsWith("i.say") || e.Message.Content.StartsWith(","))
{
return;
}
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - Exa 2020"
}
}.AddField(e.Message.Author.Username, e.Message.Content);
await e.Guild.GetChannel(693567898244874240).SendMessageAsync(embed: embedBuilder.Build());
}
static public async Task Delete(MessageDeleteEventArgs e)
{
// Ignore bots / DMs
if (e.Message.Author.IsBot || e.Guild == null)
{
return;
}
// Only update known messages
ulong id = e.Message.Id;
if (!Cache.ContainsKey(id))
{
return;
}
// Delete message
DiscordMessage response = await e.Channel.GetMessageAsync(Cache[id]);
Cache.Remove(id);
await response.DeleteAsync();
}
private static Task Discord_MessageDelete(MessageDeleteEventArgs ea)
{
var msg = ea.Message;
if (msg == null)
{
return(Task.CompletedTask);
}
var chn = msg.Channel;
if (chn == null)
{
return(Task.CompletedTask);
}
if (ea.Channel.Guild == null || (ea.Channel.Guild != null && !DatabaseClient.Ignored.Contains(ea.Channel.Guild.Id)))
{
return(DatabaseClient.LogMessageDeleteAsync(msg));
}
return(Task.CompletedTask);
}
private async Task MessageDeleted(DiscordClient sender, MessageDeleteEventArgs e)
{
var mdEntry = await GetNewEntryAsync() as DiscordAuditLogMessageEntry;
var msg = e.Message;
bool isSelfDelete = mdEntry == null;
if (msg?.Author == null) //Происходит при перезапуске бота или если сообщение устарело //msg !=null is not working properly
{
string user = isSelfDelete ? "" : ", Удаливший: " + mdEntry.UserResponsible.Mention;
await SendMessageToAuditAsync(content : $"Некэшированое сообщение удалено в канале " + e.Channel.Name + user);
return;
}
DiscordEmbedBuilder entryBuilder = new DiscordEmbedBuilder();
if (isSelfDelete)
{
if (msg.Author.IsBot)
{
return;
}
entryBuilder.SetAuthor(msg.Author);
entryBuilder.WithFooter($"Время действия {DateTime.Now.ToLongDateString()}");
}
else
{
if (mdEntry.UserResponsible.IsBot)
{
return;
}
entryBuilder = EmbedBuilderExtensions.CreateForAudit(mdEntry);
}
entryBuilder.SetTitle("Удаление сообщения");
entryBuilder.SetDescription("Сообщение удалено в канале " + e.Channel.Name);
entryBuilder.AddMesage(msg);
await SendMessageToAuditAsync(embed : entryBuilder);
}
public async Task Deleted(DiscordClient client, MessageDeleteEventArgs messageEvent)
{
if (messageEvent.Channel.Id == ChannelId)
{
// Build new message object
DeleteMessage message = new DeleteMessage(messageEvent.Message);
// Forward to SignalR
Task <HttpResponseMessage> apiTask = commsHandler.DeleteObject(message);
HttpResponseMessage response = null;
try
{
response = await apiTask;
}
catch (Exception e)
{
throw new ApplicationException("Couldn't send message to SignalR.", e);
}
// Delete from history
config.Client.HistoryStore.RemoveMessage(messageEvent.Message);
}
}
private async Task OnMessageDeleted(DiscordClient sender, MessageDeleteEventArgs eventArgs)
{
try
{
var channel = eventArgs.Channel;
var messageId = eventArgs.Message.Id;
if (channel.IsPrivate)
{
return;
}
if (IsAwardAllowedChannel(channel))
{
_awardQueue.Enqueue(new MessageAwardQueueItem(messageId, channel, MessageAwardQueueAction.MessageDeleted));
}
else if (IsAwardChannel(channel))
{
_awardQueue.Enqueue(new MessageAwardQueueItem(messageId, channel, MessageAwardQueueAction.AwardDeleted));
}
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(OnMessageDeleted));
var eventContextError = new EventErrorContext()
{
EventName = nameof(OnMessageDeleted),
User = null,
Channel = eventArgs.Channel,
Guild = eventArgs.Guild
};
await _discordErrorLogger.LogDiscordError(eventContextError, ex.ToString());
}
}
private async Task OnMessageDeleted(DiscordClient client, MessageDeleteEventArgs eventArgs)
{
try
{
var channel = eventArgs.Channel;
var message = eventArgs.Message;
var guild = eventArgs.Guild;
if (IsPrivateMessageChannel(channel))
{
return;
}
var messageId = message.Id;
var todoMessage = new MessageIdPayload(messageId, guild);
var command = new DeleteMessageCommand(todoMessage);
_emoteCommandQueue.Enqueue(command);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(OnMessageDeleted));
var eventContextError = new EventErrorContext()
{
EventName = nameof(OnMessageDeleted),
User = null,
Channel = eventArgs.Channel,
Guild = eventArgs.Guild
};
await _discordErrorLogger.LogDiscordError(eventContextError, ex.ToString());
}
}
async Task Client_MessageDeleted(MessageDeleteEventArgs e)
{
}
private Task MessageDeleted(MessageDeleteEventArgs e)
{
var guildPrefix = _redis.StringGet($"{e.Guild.Id}:CommandPrefix");
var messageEventId = _redis.StringGet($"{e.Guild.Id}:Logs:MessageEvent");
var logChannel = e.Guild.GetChannel((ulong)messageEventId);
var title = ":wastebasket: Message deleted";
if (string.IsNullOrWhiteSpace(e.Message.Content))
{
if (!string.IsNullOrWhiteSpace(messageEventId))
{
if (e.Channel != logChannel)
{
var description = $"Message ({e.Message.Id}) deleted in {e.Channel.Mention}.";
var fields = new List <EmbedField>
{
new EmbedField
{
Inline = false,
Name = "Content",
Value = "The value is not available due to the message was send while the bot were offline or it's no longer in the cache."
}
};
var footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = $"Message Id: {e.Message.Id}"
};
logChannel.SendEmbedMessageAsync(title, description, DiscordColor.IndianRed, fields: fields, footer: footer, timestamp: DateTimeOffset.UtcNow);
}
}
_logger.Information($"The message ({e.Message.Id}) was deleted in '{e.Channel.Name}' ({e.Channel.Id}) on '{e.Guild.Name}' ({e.Guild.Id}).");
}
else
{
var avatarUrl = e.Message.Author.AvatarUrl;
var description = $"Message sent by {e.Message.Author.Mention} deleted in {e.Channel.Mention}.";
if (e.Message.Author.IsBot)
{
return(Task.CompletedTask);
}
var deletedMessage = e.Message.Content;
if (e.Channel.IsPrivate)
{
_logger.Information($"The message ({e.Message.Id}) from '{e.Message.Author.GetUsertag()}' ({e.Message.Author.Id}) was updated in the direct message.");
return(Task.CompletedTask);
}
if (!deletedMessage.StartsWith(guildPrefix))
{
if (!string.IsNullOrWhiteSpace(messageEventId))
{
if (e.Channel != logChannel)
{
var attachmentCount = e.Message.Attachments.Count;
var singleImage = string.Empty;
var fields = new List <EmbedField>
{
new EmbedField
{
Inline = false,
Name = "Content",
Value = deletedMessage
}
};
var footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = $"Author: {e.Message.Author.Id} | Message Id: {e.Message.Id}"
};
if (!attachmentCount.Equals(0))
{
var attachments = new Dictionary <string, Stream>();
}
else
{
logChannel.SendEmbedMessageAsync(title, description, DiscordColor.IndianRed, fields: fields, thumbnailUrl: avatarUrl, image: singleImage, footer: footer, timestamp: DateTimeOffset.UtcNow);
}
}
}
}
_logger.Information($"The message ({e.Message.Id}) from '{e.Message.Author.GetUsertag()}' ({e.Message.Author.Id}) was deleted in '{e.Channel.Name}' ({e.Channel.Id}) on '{e.Guild.Name}' ({e.Guild.Id}).");
}
return(Task.CompletedTask);
}
public static Task OnMessageDeleted(MessageDeleteEventArgs e) => Backtrack(e.Channel, e.Message, true);
public static async Task MessageDeleteEventHandlerAsync(FreudShard shard, MessageDeleteEventArgs e)
{
if (e.Channel.IsPrivate || e.Message is null)
{
return;
}
var logchn = shard.SharedData.GetLogChannelForGuild(shard.Client, e.Guild);
if (logchn is null || e.Channel.IsExempted(shard))
{
return;
}
if (e.Message.Author == e.Client.CurrentUser && shard.SharedData.IsEventRunningInChannel(e.Channel.Id))
{
return;
}
var emb = FormEmbedBuilder(EventOrigin.Message, "Message deleted");
emb.AddField("Location", e.Channel.Mention, inline: true);
emb.AddField("Author", e.Message.Author?.Mention ?? _unknown, inline: true);
var entry = await e.Guild.GetLatestAuditLogEntryAsync(AuditLogActionType.MessageDelete);
if (!(entry is null) && entry is DiscordAuditLogMessageEntry mentry)
{
var member = await e.Guild.GetMemberAsync(mentry.UserResponsible.Id);
if (member.IsExempted(shard))
{
return;
}
emb.AddField("User responsible", mentry.UserResponsible.Mention, inline: true);
if (!string.IsNullOrWhiteSpace(mentry.Reason))
{
emb.AddField("Reason", mentry.Reason);
}
emb.WithFooter(mentry.CreationTimestamp.ToUtcTimestamp(), mentry.UserResponsible.AvatarUrl);
}
if (!string.IsNullOrWhiteSpace(e.Message.Content))
{
emb.AddField("Content", $"{Formatter.BlockCode(string.IsNullOrWhiteSpace(e.Message.Content) ? "<empty content>" : FormatterExtensions.StripMarkdown(e.Message.Content.Truncate(1000)))}");
if (shard.SharedData.MessageContainsFilter(e.Guild.Id, e.Message.Content))
{
emb.WithDescription(Formatter.Italic("Message contained a filter."));
}
}
if (e.Message.Embeds.Any())
{
emb.AddField("Embeds", e.Message.Embeds.Count.ToString(), inline: true);
}
if (e.Message.Reactions.Any())
{
emb.AddField("Reactions", string.Join(" ", e.Message.Reactions.Select(r => r.Emoji.GetDiscordName())), inline: true);
}
if (e.Message.Attachments.Any())
{
emb.AddField("Attachments", string.Join("\n", e.Message.Attachments.Select(a => a.FileName)), inline: true);
}
if (e.Message.CreationTimestamp != null)
{
emb.AddField("Message creation time", e.Message.CreationTimestamp.ToUtcTimestamp(), inline: true);
}
await logchn.SendMessageAsync(embed : emb.Build());
}