private static void MessageUpdate(BaseDiscordClient client, Embed embed, MessageUpdateEventArgs messageUpdateEventArgs)
{
var fields = new List <EmbedField>
{
new EmbedField
{
Inline = false,
Name = "Before"
}
};
fields.First()
.Value = messageUpdateEventArgs.MessageBefore != null
? messageUpdateEventArgs.MessageBefore.Content
: "The value is not available due to the message was send while the bot were offline or it's no longer in the cache.";
fields.Add(new EmbedField
{
Inline = false,
Name = "Now",
Value = Formatter.MaskedUrl("Jump to message", messageUpdateEventArgs.Message.JumpLink)
});
embed.Title = $"{DiscordEmoji.FromGuildEmote(client, EmojiLibrary.Edit)} Message updated";
embed.Description = new StringBuilder().AppendLine($"Message ({messageUpdateEventArgs.Message.Id}) updated in {messageUpdateEventArgs.Channel.Mention}.")
.ToString();
embed.Color = DiscordColor.CornflowerBlue;
embed.Thumbnail = messageUpdateEventArgs.Author.AvatarUrl;
embed.Fields = fields;
embed.Footer = new EmbedFooter {
Text = $"Author: {messageUpdateEventArgs.Author.Id} | Message Id: {messageUpdateEventArgs.Message.Id}"
};
}
internal static Task MessageEdited(DiscordClient _1, MessageUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.Guild.Id != 699555747591094344)
{
return;
}
if (e.Channel.Id == 722905404354592900)
{
return;
}
DiscordEmbedBuilder embed = new DiscordEmbedBuilder()
.WithTimestamp(e.Message.EditedTimestamp)
.WithDescription($"{e.Author.Mention} ({e.Author.Id}) edited a message in {e.Channel.Mention}\n" +
$"Message ID: {e.Message.Id}")
.AddField("Before", e.MessageBefore is null ? Formatter.Italic("Unknown") : e.MessageBefore.Content)
.AddField("After", e.Message.Content)
.AddField("Doing!", $"[Jump to message]({e.Message.JumpLink})")
.WithThumbnail(e.Author.AvatarUrl)
.WithColor(DiscordColor.Yellow);
await DiscordObjectService.Instance.LogsChannel.SendMessageAsync(new DiscordMessageBuilder().WithEmbed(embed).WithAllowedMentions(Mentions.None));
});
return(Task.CompletedTask);
}
internal async Task <Task> MessageUpdated(MessageUpdateEventArgs e)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Konsol.WriteLine(DateTime.Now.ToString() + " -> Sunucu : " + e.Guild.Name + " -> Kanal : " + e.Channel.Name + " -> Kullanıcı : " + e.Message.Author.Username + " -> Mesajı Değiştirdi : " + e.Message.Content);
return(Task.Delay(0));
}
private Task _discordClient_MessageUpdated(DiscordClient sender, MessageUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
// Early exits + if an embed appears, it is just a rich URL
if (_textChannel == null || e.Channel.Guild == null || e.Author == null ||
e.Author.IsSelf(_discordClient) ||
e.Message == e.MessageBefore && e.MessageBefore.Embeds.Count == 0 && e.Message.Embeds.Count != 0)
{
return;
}
if (e.MessageBefore != null)
{
var embedBuilder = new DiscordEmbedBuilder
{
Title = "Message Edited - Old Message Content",
Color = MomentumColor.Blue
}
.WithDescription(Formatter.MaskedUrl("Jump to Message", e.MessageBefore.JumpLink))
.AddMessageContent(e.MessageBefore);
await _textChannel.SendMessageAsync(embed: embedBuilder.Build());
}
else
{
await _textChannel.SendMessageAsync("A message was updated, but it was not in cache. " +
e.Message.JumpLink);
}
});
return(Task.CompletedTask);
}
static async Task MessageUpdated(DiscordClient client, MessageUpdateEventArgs e)
{
if (Conversation.ConversationData.ConversationMessagesByOrigId.ContainsKey(e.Message.Id))
{
await Conversation.ConversationData.ConversationMessagesByOrigId[e.Message.Id].UpdateMessage();
}
}
private async Task Discord_MessageUpdated(MessageUpdateEventArgs e)
{
if (e.Guild == RPClass.RPGuild)
{
if (e.Message.Author != e.Client.CurrentUser)
{
try
{
if (!e.Message.Content.StartsWith("!"))
{
DiscordEmbedBuilder embed = new DiscordEmbedBuilder
{
Title = "Message Edited",
Color = DiscordColor.Orange
}
.AddField("Member", e.Message.Author.Username + "#" + e.Message.Author.Discriminator + " (" + e.Message.Author.Id + ")", true)
.AddField("Channel", e.Message.Channel.Name, true)
.AddField("Creation Timestamp", e.Message.CreationTimestamp.ToString(), true)
.AddField("Edit Timestamp", e.Message.EditedTimestamp.ToString(), true)
.AddField("Old Message", e.MessageBefore.Content.Any() ? e.MessageBefore.Content : "-", false)
.AddField("New Message", e.Message.Content.Any() ? e.Message.Content : "-", false)
.AddField("Attachments", e.Message.Attachments.Any() ? string.Join("\n", e.Message.Attachments.Select(x => x.Url)) : "-", false);
await RPClass.LogChannel.SendMessageAsync(embed : embed);
}
}
catch { }
}
}
}
private static async Task Client_MessageUpdated(MessageUpdateEventArgs e)
{
if (e.Channel != null && e.Message != null && e.Author != null)
{
await ProcessMessage(e.Message, e.Author, e.Channel);
}
}
public static async Task MessageBeenUpdated(DiscordClient _, MessageUpdateEventArgs e)
{
try
{
var data = new Global().GetDBRecords(e.Guild.Id);
var channelId = Convert.ToUInt64(data.LogChannel);
var embed1 = new DiscordEmbedBuilder()
.WithAuthor($"{e.Author.FullDiscordName()} Edited a message!", icon_url: e.Author.AvatarUrl)
.WithColor(DiscordColor.Orange)
.WithDescription($"**Channel message edited 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 Edited:** {e.Message.EditedTimestamp:hh:mm:ss tt} on {e.Message.EditedTimestamp.LocalDateTime.DayOfWeek}")
.AddField("Message", $"**Before: {e.MessageBefore.Content.Length}**\n" +
$"{$"-{e.MessageBefore.Content.Truncate(250)}".BlockCode_DIFF()}\n" +
$"**After: {e.Message.Content.Length}**\n" +
$"{$"+{e.Message.Content.Truncate(250)}".BlockCode_DIFF()}");
await e.Guild.GetChannel(channelId).SendMessageAsync(embed: embed1);
}
catch (Exception exception)
{
if (exception.Message.Contains("Input string was not in a correct format."))
{
}
else
{
Console.WriteLine(exception);
throw;
}
}
}
private async Task Discord_MessageUpdated(MessageUpdateEventArgs e)
{
if (_pinsCache.TryGetValue(e.Channel.Id, out var pins))
{
if (e.Message.Pinned)
{
if (!pins.Contains(e.Message))
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => pins.Add(e.Message));
}
}
else
{
if (pins.Contains(e.Message))
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => pins.Remove(e.Message));
}
}
if (e.Channel.Id == _channel.Id)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => noMessages.Visibility = pins.Any()?Visibility.Collapsed : Visibility.Visible);
}
}
}
private async Task OnMessageUpdated(MessageUpdateEventArgs e)
{
if (MessageUpdated != null)
{
await MessageUpdated(e);
}
}
private Task OnMessageUpdated(DiscordClient client, MessageUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
var message = e.Message;
var commandStart = message.GetStringPrefixLength(m_Prefix);
if (commandStart == -1)
{
return;
}
var prefix = message.Content.Substring(0, commandStart);
var invocation = message.Content.Substring(commandStart);
var command = m_Commands.FindCommand(invocation, out var args);
if (command == null)
{
return;
}
var ctx = m_Commands.CreateContext(message, prefix, command, args);
await m_Commands.ExecuteCommandAsync(ctx);
});
return(Task.CompletedTask);
}
public static async Task MessageUpdated(MessageUpdateEventArgs args)
{
if (args.MessageBefore.Content == args.Message.Content)
{
return;
}
DiscordEmbedBuilder embed = new DiscordEmbedBuilder();
DiscordChannel logChannel = args.Guild.GetChannelByName("tux-logs");
await logChannel.TriggerTypingAsync().ConfigureAwait(false);
embed.Title = "Message Updated";
if (args.MessageBefore.Content == null)
{
embed.AddField("Old Message", "*Not in cache*");
}
else
{
embed.AddField("Old Message", args.MessageBefore.Content);
}
embed.AddField("Updated 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);
}
private async Task Client_MessageUpdated(MessageUpdateEventArgs e)
{
var guildSettings = await _guildSettingsService.GetGuildSettingsByIdAsync(e.Guild.Id);
if (guildSettings == null)
{
return;
}
// Update message from BD
await _messageService.UpdateMessageAsync(e.Message.Id, e.Message.Content);
// Log
if (guildSettings.AutoLogUpdateMessage)
{
var channel = await Client.GetChannelAsync(guildSettings.CreateMessageChannel);
if (e.Message.Author.IsBot)
{
return;
}
if (e.Channel == channel)
{
return;
}
if (e.Message.Content.StartsWith(_config.CommandPrefix))
{
return;
}
var prevMessage = await _messageService.GetMessageByIdAsync(e.Message.Id);
await _loggingMessage.UpdateAsync(channel, e.Message, prevMessage.Content);
}
}
private async Task MessageUpdated(DiscordClient sender, MessageUpdateEventArgs e)
{
if (e.Author == null || e.Author.IsBot)
{
return;
}
_entryBuilder = new DiscordEmbedBuilder
{
Author = new DiscordEmbedBuilder.EmbedAuthor {
Name = e.Author.Username, IconUrl = e.Author.AvatarUrl
},
Title = $"Сообщение отредактировано в канале {e.Message.Channel.Name}"
};
if (e.MessageBefore != null && e.MessageBefore.Content.Equals(e.Message.Content, StringComparison.OrdinalIgnoreCase))
{
return;
}
string oldContent = e.MessageBefore != null && e.MessageBefore.Content.IsRelevant() ?
e.MessageBefore.Content :
"Информация о старом содержании некэширована";
_entryBuilder.AddBeforeAfter("Содержание", oldContent, e.Message.Content);
_entryBuilder.AddField("Прямая ссылка", e.Message.JumpLink.AbsoluteUri);
await SendMessageToAuditAsync(embed : _entryBuilder);
}
public async Task MessageUpdated(MessageUpdateEventArgs e)
{
//When the chat update has been called!
foreach (Game m in games)
{
m.UpdateEditChatGame(e);
}
}
private static async Task OnMessageUpdated(MessageUpdateEventArgs e)
{
if (e.Message.Author.IsCurrent ||
e.Message.Author.IsBot)
{
return;
}
}
internal static async Task BotClient_MessageUpdated(MessageUpdateEventArgs e)
{
// Skip if (1) this channel is excluded or (2) this is sent by the bot.
if (!BotSettings.IsChannelExcluded(e.Channel) && !e.Author.IsBot)
{
CheckMessage(e.Message);
}
}
public static async Task MessageUpdateEventHandlerAsync(FreudShard shard, MessageUpdateEventArgs e)
{
if (e.Author is null || e.Author.IsBot || e.Channel is null || e.Channel.IsPrivate || e.Message is null)
{
return;
}
if (shard.SharedData.BlockedChannels.Contains(e.Channel.Id))
{
return;
}
if (e.Message.Author == e.Client.CurrentUser && shard.SharedData.IsEventRunningInChannel(e.Channel.Id))
{
return;
}
if (!(e.Message.Content is null) && shard.SharedData.MessageContainsFilter(e.Guild.Id, e.Message.Content))
{
try
{
await e.Message.DeleteAsync("bot: Filter hit after update");
await e.Channel.SendMessageAsync($"{e.Author.Mention} said: {FormatterExtensions.Spoiler(Formatter.BlockCode(FormatterExtensions.StripMarkdown(e.Message.Content)))}");
} catch
{
// swallow
}
}
var logchn = shard.SharedData.GetLogChannelForGuild(shard.Client, e.Guild);
if (logchn is null || !e.Message.IsEdited || e.Channel.IsExempted(shard))
{
return;
}
var member = await e.Guild.GetMemberAsync(e.Author.Id);
if (member.IsExempted(shard))
{
return;
}
string pcontent = string.IsNullOrWhiteSpace(e.MessageBefore?.Content) ? "" : e.MessageBefore.Content.Truncate(700);
string acontent = string.IsNullOrWhiteSpace(e.Message?.Content) ? "" : e.Message.Content.Truncate(700);
string ctime = e.Message.CreationTimestamp == null ? _unknown : e.Message.CreationTimestamp.ToUtcTimestamp();
string etime = e.Message.EditedTimestamp is null ? _unknown : e.Message.EditedTimestamp.Value.ToUtcTimestamp();
string bextra = $"Embeds: {e.MessageBefore?.Embeds?.Count ?? 0}, Reactions: {e.MessageBefore?.Reactions?.Count ?? 0}, Attachments: {e.MessageBefore.Attachments?.Count ?? 0}";
string aextra = $"Embeds: {e.Message.Embeds.Count}, Reactions: {e.Message.Reactions.Count}, Attachments: {e.Message.Attachments.Count}";
var emb = FormEmbedBuilder(EventOrigin.Message, "Message updated");
emb.WithDescription(Formatter.MaskedUrl("Jump to message", e.Message.JumpLink));
emb.AddField("Location", e.Channel.Mention, inline: true);
emb.AddField("Author", e.Message.Author?.Mention ?? _unknown, inline: true);
emb.AddField("Before update", $"Created {ctime}\n{bextra}\nContent:{Formatter.BlockCode(FormatterExtensions.StripMarkdown(pcontent))}");
emb.AddField("After update", $"Edited {etime}\n{aextra}\nContent:{Formatter.BlockCode(FormatterExtensions.StripMarkdown(acontent))}");
await logchn.SendMessageAsync(embed : emb.Build());
}
private async Task Client_MessageUpdated(MessageUpdateEventArgs e)
{
if (e.Channel != null && e.Message != null && e.Author != null)
{
if (!SingleGuild.HasValue || SingleGuild == e.Guild?.Id)
{
await ProcessMessage(e.Message, e.Author, e.Channel);
}
}
}
private static async Task DiscordOnMessageUpdated(DiscordClient ctx, MessageUpdateEventArgs e)
{
var embed = new DiscordEmbedBuilder
{
Author = new DiscordEmbedBuilder.EmbedAuthor()
{
IconUrl = e.Author.AvatarUrl,
Url = e.Message.JumpLink.ToString(),
Name = "Message Edited"
},
Color = default,
public void Enrich(Scope scope, MessageUpdateEventArgs evt)
{
scope.AddBreadcrumb(evt.Message.Content ?? "<unknown>", "event.messageEdit",
data: new Dictionary <string, string>()
{
{ "channel", evt.Channel.Id.ToString() },
{ "guild", evt.Channel.GuildId.ToString() },
{ "message", evt.Message.Id.ToString() }
});
scope.SetTag("shard", evt.Client.ShardId.ToString());
}
private async Task OnMessageUpdated(DiscordClient client, MessageUpdateEventArgs e)
{
if (string.IsNullOrWhiteSpace(e.Message.Content) &&
e.Message.Attachments.Count == 0 &&
e.Message.Embeds.Count == 0 &&
e.Message.Flags.HasValue &&
e.Message.Flags.Value.HasFlag(MessageFlags.SuppressedEmbeds))
{
_logger.LogDebug($"Deleting blank message from {e.Author.Username}({e.Author.Id}) in channel: {e.Channel.Name}/{e.Channel.Id}, guild: {e.Guild.Name}/{e.Guild.Id}");
await e.Message.DeleteAsync();
}
}
private static async Task Client_MessageUpdated(MessageUpdateEventArgs e)
{
var kuvuGuild = await e.Guild.GetKuvuGuild();
if (kuvuGuild.LogChannel.HasValue && e.Message != null && !string.IsNullOrEmpty(e.Message.Content))
{
e.Handled = true;
var channel = e.Guild.GetChannel(kuvuGuild.LogChannel.Value);
await Log("🗒", $"{e.MessageBefore?.Content ?? "*message was not fetched - can't display*"} -> {e.Message.Content}", kuvuGuild, channel, e.Author,
new List <DuckField>() { new DuckField("Channel", $"[{e.Message.Channel.Mention}]({e.Message.JumpLink.ToString()})") });
}
}
internal static async Task BotClient_MessageUpdated(MessageUpdateEventArgs e)
{
// Only continue if the channel isn't excluded, if the sender isn't the bot, if this isn't sent in PMs, and if this isn't due to a
// system messages e.g. message pinned, member joins,
if (!Program.Settings.ExcludedChannels.Contains(e.Channel.Id) &&
!e.Channel.IsPrivate &&
!e.Author.IsCurrent &&
e.Message.MessageType == MessageType.Default)
{
CheckMessage(e.Message);
}
}
private async Task OnMessageUpdated(DiscordClient client, MessageUpdateEventArgs eventArgs)
{
try
{
var message = eventArgs.Message;
var channel = eventArgs.Channel;
var guild = eventArgs.Guild;
if (message == null)
{
throw new Exception($"{nameof(eventArgs.Message)} is null");
}
// issues caused by Threads feature
if (message.Author == null)
{
return;
}
if (!IsReleventMessage(message))
{
return;
}
if (IsPrivateMessageChannel(channel))
{
return;
}
var todoMessage = new MessageCommandPayload(message, guild);
var command = new UpdateMessageCommand(todoMessage);
_emoteCommandQueue.Enqueue(command);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(OnMessageUpdated));
var eventContextError = new EventErrorContext()
{
EventName = nameof(OnMessageUpdated),
User = eventArgs.Author,
Channel = eventArgs.Channel,
Guild = eventArgs.Guild,
Message = eventArgs.Message
};
await _discordErrorLogger.LogDiscordError(eventContextError, ex.ToString());
}
}
private Task OnMessageEdit(MessageUpdateEventArgs e)
{
if (e.Message?.Content != null && e.Message.Content.StartsWith("!"))
{
ProcessCommand(e);
}
var user = e?.Author?.Username ?? string.Empty;
var text = e?.Message?.Content ?? "<< deleted >>";
WriteLine($"{DateTime.Now:yyyy-MM-dd hh:mm:ss}\tMessage.\t\t[{user}] [{text}]");
return(Task.CompletedTask);
}
public static Task OnMessageUpdated(DiscordClient _, MessageUpdateEventArgs args)
{
if (args.Channel.IsPrivate)
{
return(Task.CompletedTask);
}
if (!MessageQueue.TryGetValue(args.Channel.Id, out var queue))
{
return(Task.CompletedTask);
}
lock (queue.syncObj)
queue.AddOrReplace(args.Message);
return(Task.CompletedTask);
}
private async Task MessageUpdated(DiscordClient c, MessageUpdateEventArgs e)
{
Task.Run(async() =>
{
if (e.Channel.IsPrivate)
{
this.logger.Information($"The message ({e.Message.Id}) from '{e.Author.GetUsertag()}' ({e.Author.Id}) was updated in the direct message.");
}
else
{
if (e.MessageBefore is { } && e.Author != null && !e.Author.IsBot && !e.MessageBefore.Content.Equals(e.Message.Content))
{
await logService.GuildLogger(c, e.Guild, e, LogType.Message).ConfigureAwait(true);
this.logger.Information($"The message ({e.Message.Id}) from '{e.Author.GetUsertag()}' ({e.Author.Id}) was updated in '{e.Channel.Name}' ({e.Channel.Id}) on '{e.Guild.Name}' ({e.Guild.Id}).");
}
}
public static async Task MessageEdited(ModCoreShard bot, MessageUpdateEventArgs e)
{
await Task.Yield();
if ((!string.IsNullOrEmpty(e.MessageBefore.Content) || e.Message.Embeds.Count > 0) && !e.Message.Author.IsBot)
{
if (bot.SharedData.EditedMessages.ContainsKey(e.Channel.Id))
{
bot.SharedData.EditedMessages[e.Channel.Id] = e.MessageBefore;
}
else
{
bot.SharedData.EditedMessages.TryAdd(e.Channel.Id, e.MessageBefore);
}
}
}
static public async Task Edit(MessageUpdateEventArgs 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;
}
// Determine our goal (default for DMs)
string goal = (e.Guild != null ? e.Guild.Id.ToString() : LANG_DEFAULT);
Init(goal);
// Update message
string msg = PrepareMessage(e.Message.Content, goal);
if (msg != "")
{
bool isTooLong = (msg == TOO_LONG);
if (isTooLong)
{
return;
}
DiscordMessage response = await e.Channel.GetMessageAsync(Cache[id]);
if (response.Content != msg)
{
await response.ModifyAsync(msg);
}
}
else
{
DiscordMessage response = await e.Channel.GetMessageAsync(Cache[id]);
Cache.Remove(id);
await response.DeleteAsync();
}
}
