internal static async Task HandleReactionAdded(ISocketMessageChannel channel, SocketReaction reaction)
{
if (ReactionCommands.TryGetValue(reaction.Emote.Name, out ReactionCommand reactionCommand))
{
SocketGuildUser user = Var.Guild.GetUser(reaction.UserId);
if (user != null)
{
AccessLevel userLevel = SettingsModel.GetUserAccessLevel(user);
if (reactionCommand.HasPermission(userLevel))
{
IMessage message = await channel.GetMessageAsync(reaction.MessageId);
ReactionContext context = new ReactionContext(message, user, channel, reaction);
try
{
await reactionCommand.HandleReaction(context);
}
catch (Exception e)
{
await SendCommandExecutionExceptionMessage(e, context, reactionCommand);
}
}
}
}
}
private async Task HandleReaction(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
if (reaction.UserId == discord.CurrentUser.Id)
{
return; // If the reaction was added by the bot, ignore.
}
if (!Menus.TryGetValue(message.Id, out Menu menu))
{
return; // If it can't find a menu attached to this message, ignore.
}
if (!await menu.JudgeCriteriaAsync(reaction))
{
return; // If the conditions on the menu fail, ignore.
}
// Let the menu handle the reaction
_ = Task.Run(async() =>
{
var msg = (RestUserMessage)await channel.GetMessageAsync(message.Id);
msg?.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
if (await menu.HandleButtonPress(reaction))
{
Menus.Remove(message.Id);
}
await Task.Delay(500);
});
}
private async Task OnReactionAdded(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel channelSocket,
SocketReaction emoteSocket)
{
var msg = await channelSocket.GetMessageAsync(emoteSocket.MessageId);
// If message is not by bot or reaction added by bot
if (!msg.Author.IsBot || emoteSocket.UserId == _client.CurrentUser.Id)
{
return;
}
// var users = await msg.GetReactionUsersAsync(new Emoji("✅"), Int32.MaxValue).FlattenAsync();
switch (emoteSocket.Emote.Name)
{
case EmojiUnicode.Confirm:
EmbedBuilder embedBuilder = await SendMedia(msg);
var mediaMsg = await channelSocket.SendMessageAsync(embed : embedBuilder.Build());
await mediaMsg.AddReactionAsync(new Emoji(EmojiUnicode.Heart));
break;
case EmojiUnicode.Heart:
SocketUser user = _client.GetUser(emoteSocket.UserId);
string answer = await SaveMedia(msg, user);
await channelSocket.SendMessageAsync(answer);
break;
default: return;
}
}
public static async Task ReactionRemoved(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction emoji)
{
if (channel.Id == DiscordBot.roleChannelID && message.Id == DiscordBot.roleMessageID && emoji.UserId != DiscordBot.client.CurrentUser.Id)
{
SocketGuild guild = DiscordBot.client.GetGuild(DiscordBot.mainGuildId);
SocketGuildUser user = guild.GetUser(emoji.UserId);
switch (emoji.Emote.Name)
{
case "🔔":
await user.RemoveRoleAsync(guild.GetRole(DiscordBot.notificationRoleID));
break;
case "🕵":
await user.RemoveRoleAsync(guild.GetRole(DiscordBot.cyberSecurityRoleId));
break;
case "💻":
await user.RemoveRoleAsync(guild.GetRole(DiscordBot.programmingRoleID));
break;
default:
await(await channel.GetMessageAsync(message.Id) as RestUserMessage).RemoveReactionAsync(emoji.Emote, user);
break;
}
}
else
{
return;
}
}
private async Task Client_ReactionAdded(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel arg2, SocketReaction arg3)
{
var currentEmbed = embeds.List.FirstOrDefault(x => x.MessageId == arg3.MessageId);
if (currentEmbed == null)
{
return;
}
if (arg3.UserId == 332106465412251648)
{
return;
}
var msg = await arg2.GetMessageAsync(currentEmbed.MessageId) as SocketUserMessage;
if (arg3.Emote.Name == "◀")
{
if (currentEmbed.CurrentPage != 1)
{
await msg.ModifyAsync(x => x.Embed = currentEmbed.GetEmbed(false));
}
await arg3.Message.Value.RemoveReactionAsync(arg3.Emote, arg3.User.Value);
}
else if (arg3.Emote.Name == "▶")
{
await msg.ModifyAsync(x => x.Embed = currentEmbed.GetEmbed(true));
await arg3.Message.Value.RemoveReactionAsync(arg3.Emote, arg3.User.Value);
}
else
{
await arg3.Message.Value.RemoveReactionAsync(arg3.Emote, arg3.User.Value);
}
}
private async void AddUser()
{
if (_raidService.AddUser(_raid.RaidId, _user, _role, _availability, _usedAccount, out string resultMessage))
{
try
{
await UserExtensions.SendMessageAsync(_user, resultMessage);
IUserMessage userMessage = (IUserMessage)await _channel.GetMessageAsync(_raid.MessageId);
await userMessage.ModifyAsync(msg => msg.Embed = _raid.CreateRaidMessage());
await _logService.LogRaid($"{_raid.Users[_user.Id].Nickname} signed up as {_availability}", _raid);
}
catch { }
finally
{
_conversationService.CloseConversation(_user.Id);
}
}
else
{
resultMessage += $"\n\n{CreateSignUpMessage(_raid)}";
await UserExtensions.SendMessageAsync(_user, resultMessage);
}
}
//Kudos to Sol's mate
async Task OnReactAddedAsync(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
if (!reaction.User.IsSpecified || !JiraReporter.Settings.CheckAllowed(reaction.User.Value as SocketUser))
{
return;
}
string type;
if (reaction.Emote.Name == "🐛")
{
type = "Bug";
}
else if (reaction.Emote.Name == "🚀")
{
type = "Story";
}
else
{
return;
}
SocketTextChannel textChannel = channel as SocketTextChannel;
RestUserMessage userMessage = channel.GetMessageAsync(message.Id).Result as RestUserMessage;
Task.Run(() => new JiraReporter().Report(reaction.User.Value, client, userMessage, new InteractiveService(client, TimeSpan.FromMinutes(5)), type));
}
/// <summary>
/// The event method that gets called whenever a reaction is placed on a message
/// </summary>
/// <param name="message">the message the reaction was added to</param>
/// <param name="channel">the discord channel the message came from</param>
/// <param name="reaction">the reaction on the message from the channel</param>
/// <returns></returns>
public async Task ReactionAdded(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
// check if the esi token needs to be refreshed and refresh it
await RefreshEsiToken();
if (!channel.Name.Equals(_channelToWatch, StringComparison.OrdinalIgnoreCase))
{
Log("Reaction received in channel bot is not watching. Ignoring message");
return;
}
// check to make sure the user who placed the reaction on the message is an approved user and
// that the reaction is one we care about
if (!_approvedDiscordUsers.Contains(reaction.User.ToString()))
{
Log($"Unapproved user added reaction to message: {reaction.User}");
return;
}
if (!reaction.Emote.Name.Equals("sendmail", StringComparison.OrdinalIgnoreCase))
{
Log($"Other emote detected on message: {reaction.Emote.Name}");
return;
}
var discordMessage = await channel.GetMessageAsync(message.Id);
if (discordMessage == null)
{
Log($"Unable to find discord message from channel {channel.Name}");
return;
}
await BuildAndSendMessage(discordMessage);
}
public static async Task ReactionAdded(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
// Gets the guild channel, guild (through the guild channel), role and user.
IGuildChannel guildChannel = channel as IGuildChannel;
IGuild guild = guildChannel.Guild as IGuild;
IMessage introductionMessage = await channel.GetMessageAsync(message.Id);
SocketGuildUser messageAuthor = await guild.GetUserAsync(introductionMessage.Author.Id) as SocketGuildUser;
SocketGuildUser reactedUser = await guild.GetUserAsync(reaction.UserId) as SocketGuildUser;
IRole newUserRole = guild.Roles.FirstOrDefault(x => x.Id == newUserRoleId);
IRole moderatorRole = guild.Roles.FirstOrDefault(x => x.Id == moderatorRoleId);
IRole adminRole = guild.Roles.FirstOrDefault(x => x.Id == adminRoleId);
// Checks if the reaction was in the correct channel.
if (channel.Id == welcomeChannelId)
{
// Checks if the reaction occurred at the right message.
if (messageAuthor.Roles.Contains(newUserRole))
{
if (reactedUser.Roles.Contains(moderatorRole) || reactedUser.Roles.Contains(adminRole))
{
// Checks if the reaction was the correct emoij.
if (reaction.Emote.Name.Equals(reactionEmote))
{
await messageAuthor.RemoveRoleAsync(newUserRole);
}
}
}
}
return;
}
/// <summary>
/// Handles reactions added to messages
/// </summary>
public static async Task ReactionAddedHandler(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
IUserMessage reactionMessage;
if (reaction.Message.IsSpecified)
{
reactionMessage = reaction.Message.Value;
}
else
{
reactionMessage = await channel.GetMessageAsync(reaction.MessageId) as IUserMessage;
}
SocketTextChannel textChannel = channel as SocketTextChannel;
if ((reactionMessage != null) && (textChannel != null) && reactionMessage.Author.Id == BotCore.Client.CurrentUser.Id && reaction.User.Value.Id != BotCore.Client.CurrentUser.Id)
{
if (InteractiveMessages.TryGetValue(reactionMessage.Id, out InteractiveMessage interactiveMessage))
{
MessageInteractionContext context = new MessageInteractionContext(reaction, reactionMessage, textChannel);
if (context.IsDefined)
{
await interactiveMessage.HandleInteraction(context);
}
}
}
}
public async Task ReactionRemoved(Cacheable <IUserMessage, ulong> cachedMessage, ISocketMessageChannel channel, SocketReaction reaction)
{
//Don't trigger if the emoji is wrong, or if the user is bot
if (reaction.User.IsSpecified && reaction.User.Value.IsBot)
{
return;
}
if (reaction.Emote.Name != _emoji)
{
return;
}
//If there's an error reply when the reaction is removed, delete that reply,
//remove the cached error, remove it from the cached replies, and remove
//all reactions from the original messages
if (_errorReplies.TryGetValue(cachedMessage.Id, out var botReplyId))
{
var msg = await channel.GetMessageAsync(botReplyId);
await msg.DeleteAsync();
_associatedErrors.Remove(cachedMessage.Id);
_errorReplies.Remove(cachedMessage.Id);
var originalMessage = await cachedMessage.GetOrDownloadAsync();
await originalMessage.RemoveAllReactionsAsync();
}
}
public static async Task ReactionAdded(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
if (reaction.Emote.Name == "commend")
{
IUserMessage msg = (IUserMessage)channel.GetMessageAsync(message.Id).Result;
IUser author = msg.Author;
if (author.IsBot)
{
return;
}
IUser sender = reaction.User.Value;
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
User senderData = context.Users.FirstOrDefault(u => u.discord_id == sender.Id);
if (senderData == null || author.Id == sender.Id || senderData.discord_last_commend_hour == DateTime.Now.Hour)
{
await msg.RemoveReactionAsync(reaction.Emote, sender);
}
else
{
await AddCommend(author, sender, message.Id);
}
}
}
}
public static async Task UpdateBillboardAsync(IGuild guild, IUserMessage message, ISocketMessageChannel channel,
GovernanceVote vote, SuggestionType type)
{
var msg = GetBillboardMessage(type);
var billboard = (IUserMessage)await channel.GetMessageAsync(vote.VoteBillboardId);
if (billboard == null)
{
return;
}
if (type == SuggestionType.Vote)
{
var embed = await AddVotesAsync(guild, new EmbedBuilder(), message);
await billboard.ModifyAsync(props =>
{
props.Content = msg;
props.Embed = embed.WithTitle("Votes").Build();
});
}
else
{
await billboard.ModifyAsync(props =>
{
props.Content = msg;
props.Embed = null;
});
}
}
private async Task ReactionAdded(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel arg2, SocketReaction arg3)
{
if (arg3.UserId == bot.CurrentUser.Id)
{
return;
}
var message = await arg2.GetMessageAsync(arg1.Id);
if (message == null || !(arg2 is SocketGuildChannel))
{
return;
}
var embed = message.Embeds.FirstOrDefault();
if (embed == null || string.IsNullOrEmpty(embed.Description))
{
return;
}
var guildConfig = Config.GetServerConfig(((SocketGuildChannel)arg2).Guild.Id, ChatTypes.Discord);
//var message = arg1.Value;
var channel = (SocketGuildChannel)arg2;
var user = channel.Guild.GetUser(arg3.UserId);
var parser = GetParser(guildConfig);
var post = parser.ParsePostFromPostMessage(message.Embeds.First().Description, guildConfig);
if (post != null && user != null)
{
if (DeleteEmojis.Contains(arg3.Emote.Name))//thumbs down will be quick way to delete a raid by poster/admin
{
await DeletePost(post, user.Id, user.GuildPermissions.Administrator || user.GuildPermissions.ManageGuild);
}
else
{
var joinedUser = post.JoinedUsers.FirstOrDefault(x => x.Id == user.Id);
if (joinedUser != null)
{
joinedUser.PeopleCount++;
}
else
{
post.JoinedUsers.Add(new PokemonRaidJoinedUser(user.Id, guildConfig.Id, post.UniqueId, user.Username, 1));
}
var messages = await MakePost(post, parser);
var tasks = new List <Task>();
foreach (var resultmessage in messages.Where(x => x.Channel.Id != message.Channel.Id))
{
tasks.Add(resultmessage.AddReactionAsync(arg3.Emote.Name));
}
Task.WaitAll(tasks.ToArray());
Config.Save();
}
}
}
private async Task ReactionAdded(Cacheable <IUserMessage, ulong> cachableMessage, ISocketMessageChannel channel, SocketReaction reaction)
{
try {
if (channel == null)
{
return;
}
IGuild guild = ((IGuildChannel)channel).Guild;
IMessage message = await channel.GetMessageAsync(cachableMessage.Id);
if (message.Author.Id == Cirilla.Client.CurrentUser.Id)
{
ulong id = message.MentionedUserIds.FirstOrDefault();
IGuildUser user = await guild.GetUserAsync(id);
if (id != 0)
{
Kick(user, (IUserMessage)message, guild);
}
}
} catch {
// error
}
}
private async Task OnReactionRemoved(Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel channel, SocketReaction reaction)
{
// Check if reaction on message was a reaction on a tracked message
ulong eventTrackingId = 0;
foreach (ulong id in Config.messageIdTracker)
{
if (reaction.MessageId == id)
{
eventTrackingId = id;
}
}
// Ignore bot reactions
if (reaction.User.Value.IsBot)
{
return;
}
// Execute correct handler
try {
var message = channel.GetMessageAsync(eventTrackingId).Result as RestUserMessage;
var em = message.Embeds.First();
// If tracked message is an event
if (em.Footer.Value.ToString().Contains("Event"))
{
await HandleEventAsync(cache, channel, reaction, message, false);
}
} catch (Exception e) {
await LogAsync(new LogMessage(LogSeverity.Debug, "bot", e.ToString()));
}
}
private static async Task OnReactionRemoved(ulong MessageID, ISocketMessageChannel NewMsg, SocketReaction react)
{
if (MessageID == ServerConfigData.ServerRoleSetUpMsgID && react.UserId != Program.ServerConfigData.PointersAnonUserID["Quantum Bot"])
{
foreach (KeyValuePair <string, ChannelRoles> EmoteData in Program.ChannelRolesData)
{
if (react.Emote.Equals(EmoteData.Value.ChannelReactEmote))
{
await(react.User.Value as SocketGuildUser).RemoveRoleAsync((NewMsg as SocketGuildChannel).Guild.GetRole(EmoteData.Value.RoleID));
//NO LOGIC CHECK FOR WHO GETS WHAT ROLES
await(NewMsg as SocketGuildChannel).Guild.GetTextChannel(ServerConfigData.PointersAnonChatID["Bot History"]).SendMessageAsync($"User <@{react.UserId}> removed role {EmoteData.Key}");
return;
}
}
return;
}
foreach (BulletinEvent bulletinEvent in Program.BulletinBoardData.BulletinEvents)
{
if (MessageID == bulletinEvent.MsgID && react.UserId != Program.ServerConfigData.PointersAnonUserID["Quantum Bot"] && react.Emote.Equals(BulletinBoardData.BulletinAttendingEmote))
{
if (bulletinEvent.AttendingUsers.Contains(react.UserId) == true)
{
bulletinEvent.AttendingUsers.Remove(react.UserId);
await(NewMsg as SocketGuildChannel).Guild.GetTextChannel(ServerConfigData.PointersAnonChatID["Bot History"]).SendMessageAsync($"User <@{react.UserId}> is no longer going to the Event \"{bulletinEvent.Title}\"");
}
var builder = new EmbedBuilder()
.WithTitle(bulletinEvent.Title)
.WithUrl($"{bulletinEvent.EventURL}")
.WithColor(new Color(0, 0, 255))
.WithDescription($"{bulletinEvent.Description}")
.WithThumbnailUrl($"{bulletinEvent.IconURL}")
.AddField($"Time", bulletinEvent.EventDate.ToString("MMMM d yyyy \ndddd h:mm tt"), true)
.AddField($"Location", $"{bulletinEvent.Location}", true)
.AddField($"Cost", $"{bulletinEvent.Cost}", true)
.AddField($"Capacity", $"{bulletinEvent.Capacity}", true)
.AddField($"Attending", $"{bulletinEvent.AttendingUsers.Count}", true)
.WithFooter($"By {(await NewMsg.GetUserAsync(bulletinEvent.author) as SocketGuildUser).Nickname}", $"{bulletinEvent.authorIconURL}")
.WithTimestamp(bulletinEvent.embedCreated);
var embed = builder.Build();
var msg = await NewMsg.GetMessageAsync(MessageID) as IUserMessage;
await msg.ModifyAsync(x => x.Embed = embed);
//add atending emote
SaveBulletinBoardDataToFile();
await msg.AddReactionAsync(BulletinBoardData.BulletinAttendingEmote);
return;
}
}
}
private async Task ReactionAdded(Cacheable <IUserMessage, ulong> msg, ISocketMessageChannel chan, SocketReaction reaction)
{
if (roles.ContainsKey(reaction.Emote.Name))
{
var role = roles[reaction.Emote.Name];
if (msg.Id == role.Item1)
{
IGuildUser author = (IGuildUser)reaction.User.Value;
if (!author.RoleIds.Contains(role.Item2.Id))
{
await author.AddRoleAsync(role.Item2);
}
}
}
if (factions.ContainsKey(reaction.Emote.Name))
{
var role = factions[reaction.Emote.Name];
if (msg.Id == role.Item1)
{
if (factionBlacklist.Contains(reaction.UserId)) // We ignore blacklisted users
{
await(await msg.GetOrDownloadAsync()).RemoveReactionAsync(reaction.Emote, reaction.User.Value);
return;
}
IGuildUser author = (IGuildUser)reaction.User.Value;
foreach (var elem in factions) // If the user was already in another faction
{
if (elem.Key == reaction.Emote.Name)
{
continue;
}
var elemMsg = (IUserMessage)await chan.GetMessageAsync(elem.Value.Item1);
KeyValuePair <IEmote, ReactionMetadata>?react = elemMsg.Reactions.FirstOrDefault(x => x.Value.IsMe && x.Key.Name == elem.Key);
if (react != null)
{
await author.RemoveRoleAsync(elem.Value.Item2);
await elemMsg.RemoveReactionAsync(react.Value.Key, reaction.User.Value);
break;
}
}
if (!author.RoleIds.Contains(role.Item2.Id))
{
await author.AddRoleAsync(role.Item2);
}
if (defaultFactions.ContainsKey(author.GuildId))
{
ulong id = defaultFactions[author.GuildId].Id;
if (author.RoleIds.Any(x => x == id))
{
await author.RemoveRoleAsync(defaultFactions[author.GuildId]);
}
}
}
}
}
private async Task _client_ReactionAdded(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel arg2, SocketReaction arg3)
{
var amount = 0;
if (arg3.Emote.Name == "10")
{
amount = 10;
}
if (arg3.Emote.Name == "50")
{
amount = 50;
}
if (amount == 0)
{
return;
}
var message = await arg2.GetMessageAsync(arg3.MessageId);
var toId = message.Author.Id;
var fromId = arg3.UserId;
//if(toId == fromId)
//{
// return;
//}
IDMChannel fromDmChannel = null;
if (arg3.User.IsSpecified)
{
fromDmChannel = await arg3.User.Value.GetOrCreateDMChannelAsync();
}
else
{
var user = await _rclient.GetUserAsync(fromId);
fromDmChannel = await user.GetOrCreateDMChannelAsync();
}
var toDmChannel = await message.Author.GetOrCreateDMChannelAsync();
using (var scope = Services.CreateScope())
{
var service = ActivatorUtilities.CreateInstance <ReactionSendService>(scope.ServiceProvider);
await service.SendCoin(fromId, toId, amount, fromDmChannel, toDmChannel);
}
//arg2.GetMessageAsync()
await Task.Yield();
Console.WriteLine();
}
public async Task <IMessage> GetMessage(ulong messageId, ISocketMessageChannel channel)
{
if (testMode)
{
return(null);
}
return(await channel.GetMessageAsync(messageId));
}
private async Task OnReactionsClearedAsync(Cacheable <IUserMessage, UInt64> cachedMessage, ISocketMessageChannel channel)
{
var message = cachedMessage.HasValue
? cachedMessage.Value
: await channel.GetMessageAsync(cachedMessage.Id) as IUserMessage;
var emojis = this._userRoles.Where(r => r.MessageId == message.Id)
.Select(r => r.EmojiId.HasValue ? (IEmote)Emote.Parse($"<:rs:{r.EmojiId}>") : new Emoji(r.EmojiName));
await message.AddReactionsAsync(emojis.ToArray());
}
protected override async Task HandleReactionAsync(
Cacheable <IUserMessage, ulong> cachedMessage,
ISocketMessageChannel channel,
SocketReaction reaction)
{
var message = await channel.GetMessageAsync(reaction.MessageId).ConfigureAwait(false);
if (message is RestUserMessage userMessage)
{
await SendToBestChannelAsync(userMessage).ConfigureAwait(false);
}
}
private Task HandleUpdate(Cacheable <IMessage, ulong> before, SocketMessage after, ISocketMessageChannel channel)
{
if (!(after is SocketUserMessage afterSocket))
{
return(Task.CompletedTask);
}
_ = Task.Run(async() =>
{
ulong?id;
if ((id = GetOurMessageIdFromCache(before.Id)) != null)
{
var botMessage = await channel.GetMessageAsync(id.Value) as IUserMessage;
if (botMessage == null)
{
return;
}
int argPos = 0;
if (!afterSocket.HasMentionPrefix(_client.CurrentUser, ref argPos))
{
return;
}
var reply = await BuildReply(afterSocket, after.Content.Substring(argPos));
if (reply.Item1 == null && reply.Item2 == null && reply.Item3 == null)
{
return;
}
var pagination = (PaginationService)_services.GetService(typeof(PaginationService));
var isPaginatedMessage = pagination.IsPaginatedMessage(id.Value);
if (reply.Item3 != null)
{
if (isPaginatedMessage)
{
await pagination.UpdatePaginatedMessageAsync(botMessage, reply.Item3);
}
else
{
await pagination.EditMessageToPaginatedMessageAsync(botMessage, reply.Item3);
}
}
else
{
if (isPaginatedMessage)
{
pagination.StopTrackingPaginatedMessage(id.Value);
_ = botMessage.RemoveAllReactionsAsync();
}
await botMessage.ModifyAsync(x => { x.Content = reply.Item1; x.Embed = reply.Item2?.Build(); });
}
}
});
return(Task.CompletedTask);
}
private Task OnMessageModified(Cacheable <IMessage, ulong> cacheable, SocketMessage after, ISocketMessageChannel channel)
{
_ = Task.Run(async() =>
{
// Prevent the double reply that happens when the message is "updated" with an embed or image/video preview.
if (string.IsNullOrEmpty(after?.Content) || after.Source != MessageSource.User)
{
return;
}
IMessage before = cacheable.Value;
if (string.IsNullOrEmpty(before?.Content) || before.Content == after.Content)
{
return;
}
if (TryGetValue(cacheable.Id, out ulong responseId))
{
var response = await channel.GetMessageAsync(responseId);
if (response == null)
{
await _logger(new LogMessage(LogSeverity.Warning, "CmdCache", $"A command message ({cacheable.Id}) associated to a response was found but the response ({responseId}) was already deleted."));
TryRemove(cacheable.Id);
}
else
{
if (response.Attachments.Count > 0)
{
await _logger(new LogMessage(LogSeverity.Verbose, "CmdCache", $"Attachment found on response ({responseId}). Deleting the response..."));
_ = response.DeleteAsync();
TryRemove(cacheable.Id);
}
else
{
await _logger(new LogMessage(LogSeverity.Verbose, "CmdCache", $"Found a response associated to command message ({cacheable.Id}) in cache."));
if (response.Reactions.Count > 0)
{
bool manageMessages = response.Author is IGuildUser guildUser && guildUser.GetPermissions((IGuildChannel)response.Channel).ManageMessages;
if (manageMessages)
{
await _logger(new LogMessage(LogSeverity.Verbose, "CmdCache", $"Removing all reactions from response ({responseId})..."));
await response.RemoveAllReactionsAsync();
}
}
}
}
}
_ = _cmdHandler(after);
});
return(Task.CompletedTask);
}
/// <summary>
/// Handles the Reaction Added event.
/// </summary>
/// <param name="cachedMessage">Message that was reaction is on.</param>
/// <param name="originChannel">Channel where the message is located.</param>
/// <param name="reaction">Reaction made on the message.</param>
/// <returns>Task Complete.</returns>
private async Task <Task> HandleReactionAdded(Cacheable <IUserMessage, ulong> cachedMessage,
ISocketMessageChannel originChannel, SocketReaction reaction)
{
IMessage message = await originChannel.GetMessageAsync(cachedMessage.Id);
SocketGuildChannel chnl = message.Channel as SocketGuildChannel;
ulong guild = chnl.Guild.Id;
IUser user = reaction.User.Value;
if (message != null && reaction.User.IsSpecified && !user.IsBot)
{
if (RaidCommandParent.IsRaidMessage(message.Id))
{
await RaidCommandParent.RaidMessageReactionHandle(message, reaction);
}
else if (RaidCommandParent.IsRaidSubMessage(message.Id))
{
await RaidCommandParent.RaidSubMessageReactionHandle(message, reaction);
}
else if (RaidCommandParent.IsRaidGuideMessage(message.Id))
{
await RaidCommandParent.RaidGuideMessageReactionHandle(message, reaction);
}
else if (DexCommandParent.IsDexSelectMessage(message.Id))
{
await DexCommandParent.DexSelectMessageReactionHandle(message, reaction, guild);
}
else if (DexCommandParent.IsDexMessage(message.Id))
{
await DexCommandParent.DexMessageReactionHandle(message, reaction, guild);
}
else if (DexCommandParent.IsCatchMessage(message.Id))
{
await DexCommandParent.CatchMessageReactionHandle(message, reaction);
}
else if (POICommands.IsPOISubMessage(message.Id))
{
await POICommands.POIMessageReactionHandle(message, reaction, guild);
}
else if (HelpCommands.IsHelpMessage(message.Id))
{
await HelpCommands.HelpMessageReactionHandle(message, reaction, guild);
}
else if (Connections.IsNotifyMessage(message.Id))
{
await Connections.NotifyMessageReactionHandle(message, reaction, chnl.Guild);
}
}
return(Task.CompletedTask);
}
public async Task Handle(Cacheable <IUserMessage, ulong> msg, ISocketMessageChannel chan, SocketReaction r)
{
if (r.UserId == Program._client.CurrentUser.Id)
{
return;
}
if (r.MessageId == BotConfig.GetCachedConfig().InternalMessageId)
{
if (r.Emote.Name == "🔄")
{
var actualMessage = await chan.GetMessageAsync(r.MessageId);
await actualMessage.RemoveReactionAsync(r.Emote, r.UserId);
if (!debounce && !ServerStateManager.Instance().IsWorking) // ignore attempts to spam the button
{
debounce = true;
var status = await ServerStateManager.Instance().GetState();
if (status.InstanceState.Code == 80)
{
Console.WriteLine("User ID" + r.UserId + " initated a server start.");
ThreadPool.QueueUserWorkItem(async delegate
{
try
{
await ServerStateManager.Instance().StartServer();
}
catch (AmazonEC2Exception e)
{
Console.WriteLine("AWS threw an error.");
Console.Write(e.Message);
ServerStateManager.Instance().IsWorking = false;
await Embeds.EditMessage(Embeds.ServerStopped("The server could not be started previously due to an error. Please wait a bit and try again, or ask an admin if this persists. This mainly happens after starting a server when it's just been stopped."));
}
});
}
else
{
Console.WriteLine("Rejecting refresh as server is not stopped.");
if (Program._client.GetUser(r.UserId) != null)
{
var usr = await chan.GetUserAsync(r.UserId);
await usr.SendMessageAsync(embed : Embeds.Error("The server must be stopped for the refresh button to work."));
}
}
debounce = false;
}
}
}
}
public static async Task deleteMessageWithId(ISocketMessageChannel channel, ulong id)
{
if (id == 0 || channel == null)
{
return;
}
var msg = await channel.GetMessageAsync(id);
if (msg != null)
{
await msg.DeleteAsync();
}
}
public async Task Update(string messageID, string update)
{
var message = await _responseChannel.GetMessageAsync(Convert.ToUInt64(messageID));
if (message is RestUserMessage rumess)
{
var embed = DiscordHelper.CreateEmbeddedMessage(update);
await rumess.ModifyAsync(msg => msg.Embed = embed);
_lastMessagedInteractedWith = rumess;
}
}
public async Task UnpinEventMessage(ISocketMessageChannel channel, Event @event)
{
if (@event.MessageId == null)
{
return;
}
IUserMessage msg = ((IUserMessage)await channel.GetMessageAsync(Convert.ToUInt64(@event.MessageId)));
if (msg != null)
{
await msg.UnpinAsync();
}
}
private async Task <Task> ClearReactionsAfterDelay(ISocketMessageChannel channel)
{
while (activeMBEmbeds.Count > 0)
{
Log.Write("MB Windows - Checking For Inactive MB Windows from total of " + activeMBEmbeds.Count, "Bot");
DateTime runTime = DateTime.Now;
foreach (KeyValuePair <ulong, ActiveMBWindow> mb in activeMBEmbeds)
{
if ((runTime - mb.Value.LastInteractedWith).TotalSeconds > 20)
{
Log.Write("MB Windows - Clearing MB Command: " + mb.Key, "Bot");
IMessage message = await channel.GetMessageAsync(mb.Key);
// Convert to UserMessage so we can edit the embed to remove the react help message
if (message is IUserMessage userMessage)
{
// Get the embed and duplicate
IEmbed embed = message.Embeds.FirstOrDefault();
EmbedBuilder builder = new EmbedBuilder()
.WithTitle(embed.Title)
.WithColor(embed?.Color ?? Color.Teal)
.WithDescription(embed?.Description)
.WithThumbnailUrl(embed?.Thumbnail?.Url ?? string.Empty);
// Get MB field and duplicate - remove reaction hint text
EmbedField field = embed?.Fields.GetFirst() ?? default;
builder.AddField(new EmbedFieldBuilder()
.WithName(field.Name)
.WithValue(field.Value.Substring(0, field.Value.Length - 124)));
await userMessage.ModifyAsync(x => x.Embed = builder.Build());
}
// Remove reactions
await message.RemoveAllReactionsAsync();
activeMBEmbeds.Remove(mb.Key);
}
}
Log.Write("MB Windows - Begin Wait", "Bot");
await Task.Delay(15000);
}
Log.Write("MB Windows - All MB Windows Inactive", "Bot");
Program.DiscordClient.ReactionAdded -= this.OnReactionAdded;
return(Task.CompletedTask);
}
