public static async Task Spectator_ReactionRem(MessageReactionRemoveEventArgs e) { if (e.User.GetMember().Roles.Contains(Global.Roles[PublicRole.Spectator])) { await e.Message.DeleteReactionAsync(e.Emoji, e.User, $"Spectator {e.User.Username} can't vote"); } }
// Client has revoked a role internal static Task Role_Revoked(MessageReactionRemoveEventArgs e, DiscordMember member, DiscordRole role) { e.Client.DebugLogger.LogMessage(LogLevel.Debug, "Rolebot", $"User: {member} Role Revoked: {role}", DateTime.Now); return(Task.CompletedTask); }
public async Task HandleRemoveReactionAsync(DiscordClient client, MessageReactionRemoveEventArgs args) { if (args.Emoji.Id > 0L) { //It's a custom emoji var emoji = $":{args.Emoji.Name}:"; try { var emojiObj = DiscordEmoji.FromName(client, emoji); } catch (ArgumentException) { _logger.LogInformation($"{args.Message.Author.Username} removed a reaction of an emoji not present on this server: {emoji}. Ignoring..."); return; } _logger.LogInformation($"{args.User.Username} removed reaction {emoji}"); await _database.RemoveEmojiAsync(new LogEmoji { EmojiId = $":{args.Emoji.Name}:", Username = args.User.Username, MessageTimestamp = TimeZoneInfo.ConvertTimeFromUtc(args.Message.Timestamp.UtcDateTime, TZConvert.GetTimeZoneInfo("Romance Standard Time")), IsReaction = true }); } }
private async Task ReactionRemoved(MessageReactionRemoveEventArgs e) { if (e.Guild == null) { return; } if (e.User.IsBot) { return; } var categories = categoryCache.Query().Where(x => x.ChannelId == e.Channel.Id).ToList(); var category = categories.FirstOrDefault(x => x.MessageId == e.Message.Id); if (!categories.Any() || category == null) { return; } if (!category.Data.ContainsKey(e.Emoji.Id)) { await e.Message.DeleteReactionAsync(e.Emoji, e.User); return; } var member = await e.Guild.GetMemberAsync(e.User.Id); await member.RevokeRoleAsync(e.Guild.GetRole(category.Data[e.Emoji.Id])); }
private Task _discordClient_MessageReactionRemoved(DiscordClient sender, MessageReactionRemoveEventArgs e) { _ = Task.Run(async() => { if (e.Guild == null && e.Emoji == null || _textChannel == null || e.Channel.Id != _textChannel.Id || e.Emoji != _config.MentionRoleEmoji) { return; } // Check that the message reacted to is a role embed if (_existingRoleEmbeds.ContainsValue(e.Message.Id)) { if (e.User is DiscordMember member) { // Ignore actions from the bot if (member.IsSelf(_discordClient)) { return; } var(result, role) = await TryParseRoleFromEmbedAsync(e.Message); if (result) { await member.RevokeRoleAsync(role); } } } }); return(Task.CompletedTask); }
private async Task MessageReactionRemove(MessageReactionRemoveEventArgs 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; } foreach (var e in rm.EmojiToRole) { var emoji = await e.GetEmoji(); if (emoji != args.Emoji) { continue; } var member = await args.Channel.Guild.GetMemberAsync(args.User.Id); await member.RevokeRoleAsync(args.Channel.Guild.GetRole(e.Role)); return; } } }
public MessageReactionEventArgs(MessageReactionRemoveEventArgs e) { Message = e.Message; Channel = e.Channel; User = e.User; Emoji = e.Emoji; }
async Task HandleReactionRemove(MessageReactionRemoveEventArgs eventargs) { await Task.Yield(); foreach (var req in _requests) { var emojis = await req.GetEmojisAsync(); var msg = await req.GetMessageAsync(); var usr = await req.GetUserAsync(); if (msg.Id == eventargs.Message.Id) { if (eventargs.User.Id == usr.Id) { await PaginateAsync(req, eventargs.Emoji); } if (eventargs.Emoji != emojis.Left && eventargs.Emoji != emojis.SkipLeft && eventargs.Emoji != emojis.Right && eventargs.Emoji != emojis.SkipRight && eventargs.Emoji != emojis.Stop) { await msg.DeleteReactionAsync(eventargs.Emoji, eventargs.User); } } } }
public async Task <EventHandlerResult> Handle(MessageReactionRemoveEventArgs eventArgs) { if (eventArgs.User.IsBot) { return(EventHandlerResult.Continue); } ICollection <ulong> mappings = await _roleBindingsService.FindMappingAsync(eventArgs.Channel.Id, eventArgs.Message.Id, eventArgs.Emoji.Name); if (!mappings.Any()) { return(EventHandlerResult.Continue); } DiscordMember member = await eventArgs.Guild.GetMemberAsync(eventArgs.User.Id); await Task.Run(async() => { foreach (ulong roleId in mappings) { DiscordRole?role = eventArgs.Guild.GetRole(roleId); if (role == null) { continue; } await member.RevokeRoleAsync(role, "Remove role because of binding"); } }); return(EventHandlerResult.Stop); }
private static async Task ReactionRemoved(DiscordClient sender, MessageReactionRemoveEventArgs e) { if (e.Channel.Name != "welcome") { return; } String roleName = e.Emoji.GetDiscordName() switch { ":red_circle:" => "he/him", ":yellow_circle:" => "they/them", ":green_circle:" => "she/her", _ => null }; if (roleName == null) { return; } DiscordRole role = e.Guild.Roles.Values.FirstOrDefault(x => x.Name == roleName); if (role == null) { return; } if (e.User is not DiscordMember member) { return; } await member.RevokeRoleAsync(role); }
public static async Task BuildVoteRemoveHandler(MessageReactionRemoveEventArgs e) { if (e.Channel.Name == "builds") { using (var db = new BuildContext()) { var build = db.Builds.FirstOrDefault(b => b.MessageId == e.Message.Id); if (build == null) { return; } if (e.Emoji == DiscordEmoji.FromName(Program.Client, ":arrow_up:")) { build.UpVotes--; } else if (e.Emoji == DiscordEmoji.FromName(Program.Client, ":arrow_down:")) { build.DownVotes--; } db.Update(build); await db.SaveChangesAsync(); } } }
public async Task CheckReactionRemovedAsync(MessageReactionRemoveEventArgs e) { if (e.User.Id == Application.Current.Discord.CurrentUser.Id) { // We don't want to respond to our own reactions. return; } var roleCategory = Application.Current.Settings.ReactionRoles.FirstOrDefault(x => x.DiscordMessageId == e.Message.Id); if (roleCategory == null) { return; } // It is a reaction message we sent; handle it. // Grab required role: var role = roleCategory.Roles.FirstOrDefault(x => x.Emoji == e.Emoji); if (role == null) { // TODO: log return; } await((DiscordMember)e.User).RevokeRoleAsync(e.Guild.Roles.Values.First(x => x.Name == role.RoleName)); }
private async Task OnMessageReactionRemoved(MessageReactionRemoveEventArgs e) { if (MessageReactionRemoved != null) { await MessageReactionRemoved(e); } }
private static Task Discord_ReactionRemoved(MessageReactionRemoveEventArgs ea) { if (ea.Channel.Guild == null || (ea.Channel.Guild != null && !DatabaseClient.Ignored.Contains(ea.Channel.Guild.Id))) { return(DatabaseClient.LogReactionAsync(ea.Emoji, ea.User, ea.Message, ea.Channel, false)); } return(Task.CompletedTask); }
public async Task OnMessageReactionRemovedAsync(DiscordClient client, MessageReactionRemoveEventArgs e) { if (!e.User.IsCurrent && await _service.GetTrackedRoleIdAsync(e.Message, e.Emoji) is not 0 and ulong roleId) { await((DiscordMember)e.User).RevokeRoleAsync(e.Guild.GetRole(roleId)); _logger.LogDebug("RoleMessage {MessageId} : Revoked role {RoleId} on {User}.", e.Message.Id, roleId, e.User); } }
/// <summary> /// When an emoji is removed from a post the bot will identify whether the relevant message /// is one of its own, then react accordingly by firing applicable reaction methods. /// </summary> /// <param name="client">The discord client sending the message.</param> /// <param name="args">An object describing the context of the message sent.</param> /// <returns>A task to handle processing of the command.</returns> private async Task OnReactionRemoved(DiscordClient client, MessageReactionRemoveEventArgs args) { // Bots shouldn't handle their own reactions. if (!args.User.IsBot) { TConfig config = GetConfig(args.Guild.Id); await ReactionRemoved(new ReactionRemoveArgs <TConfig>(args, config)); } }
private static async Task onreactionremoved(MessageReactionRemoveEventArgs e) { // if reaction was made on a vote message and reaction is a valid vote emoji if (MoveVotes.Exists(v => v.Message.Equals(e.Message)) && e.Emoji == DiscordEmoji.FromName(Client, ":twisted_rightwards_arrows:")) { await HandleVoteReaction(e.Message, false); } }
protected virtual void ReactionRemoved(MessageReactionRemoveEventArgs e) { if (!CheckRequirements(e.Channel, e.Message)) { return; } OnReactionRemoved?.Invoke(e); }
private Task OnReactionRemoved(MessageReactionRemoveEventArgs e) { if (e.Message.Id != Message.Id) { return(Task.CompletedTask); } UpdateReactions(); return(Task.CompletedTask); }
/* Reaction_Removed Event Handler * Checks if the emoji and the message is being watched * * Then gets roles that need to be revoked based on emoji. * * If admin has enabled autoremoval of members based on reactions, all members who haven't reacted with a * particular emote AND have the specified role, have their role revoked * * If admin has disabled autoremoval of members based on reactions, each member is revoked on a per event base */ private static async Task Reaction_Removed(MessageReactionRemoveEventArgs e) { // increase efficiency by ensuring that emotes that aren't being watched don't trigger unnecessary exceptions if (!Config.RolesToWatch.Select(r => r.GetEmoji()).ToList().Contains(e.Emoji)) { return; } var roleExists = Config.RolesToWatch.Select(r => r.GetMessage()).ToList().Contains(e.Message); if (roleExists) { // selects the role that is supposed to be revoked // select role where emoji is emoji removed var roleToRevoke = GetRoleWatches(e).ToList(); if (!Config.AutoRemoveFlag) { // retro actively tries to remove roles (created in case bot goes offline) var guildMembers = roleToRevoke.First().GetGuild().GetAllMembersAsync().Result; // gets all the members reacted then gets members from the guild var membersReacted = from discordUser in e.Message.GetReactionsAsync(e.Emoji).Result select roleToRevoke.First().GetGuild().GetMemberAsync(discordUser.Id).Result; // filters members to remove // select member from guild members where reacted members doesn't contain the member var membersToRemove = from discordMember in guildMembers where !membersReacted.Contains(discordMember) select discordMember; // retroactively removes roles foreach (var member in membersToRemove) { // optimisation to reduce iterations if member doesn't have the role if (!member.Roles.Contains(roleToRevoke.First().GetRole())) { continue; } await member.RevokeRoleAsync(roleToRevoke.First().GetRole()); await LogPrinter.Role_Revoked(e, member, roleToRevoke.First().GetRole()); } } // If autoremoval of members if off else { var member = roleToRevoke.First().GetGuild().GetMemberAsync(e.User.Id).Result; await member.RevokeRoleAsync(roleToRevoke.First().GetRole()); await LogPrinter.Role_Revoked(e, member, roleToRevoke.First().GetRole()); } } }
public async Task <IReactionHandler.Result> HandleRemoveAsync(MessageReactionRemoveEventArgs eventArgs) { DiscordEmoji emoji = eventArgs.Emoji; if (eventArgs.Guild.Emojis.ContainsKey(emoji.Id)) { await _emojiCounterService.DecrementAsync(emoji.Id); } return(IReactionHandler.Result.Continue); }
private Task ReactionRemoved(MessageReactionRemoveEventArgs e) { if (e.User.IsCurrent) { return(Task.CompletedTask); } if (e.Message.Id == _lastBotMessage.Id) { Console.WriteLine("[{0}] {1} removed reaction {2}", e.User.Id, e.User.Username, e.Emoji.GetDiscordName()); OnReactionRemoved?.Invoke(e); } return(Task.CompletedTask); }
private async Task OnReactionRemoved(MessageReactionRemoveEventArgs e) { if (e.Channel.Id.ToString() == pugAnnouncementsChannel_ID) { var player = db.GetPlayer(e.User).Result; var eve = db.GetEvent(e.Message).Result; await db.UpdateRegistration(player, eve); await e.Guild.GetMemberAsync(e.User.Id).Result .SendMessageAsync($"You have removed yourself from the pug occuring on {eve.Scheduled_Date.ToShortDateString()} at {eve.Scheduled_Date.ToShortTimeString()}."); } await Task.CompletedTask; }
async Task HandleReactionRemove(DiscordClient client, MessageReactionRemoveEventArgs eventargs) { await Task.Yield(); // foreach request remove foreach (var req in _requests) { if (req.message.Id == eventargs.Message.Id && req.user == eventargs.User) { req._collected = eventargs.Emoji; req._tcs.TrySetResult(req._collected); } } }
public async Task ReactOnRemove(MessageReactionRemoveEventArgs messageReactionRemove, DiscordClient client) { if (messageReactionRemove.Message.Id == rolemsg) { if (messageReactionRemove.Emoji.Id == hcRoleEmote) { DiscordUser user = messageReactionRemove.User; DiscordGuild guild = await client.GetGuildAsync(hcGuildId); DiscordMember member = await guild.GetMemberAsync(user.Id); await member.RevokeRoleAsync(guild.GetRole(testGroup), "Role react"); } } }
private Task HandleReactionRemove(DiscordClient client, MessageReactionRemoveEventArgs eventargs) { foreach (var req in this._requests) { // match message if (req._message.Id == eventargs.Message.Id && req._message.ChannelId == eventargs.Channel.Id) { if (eventargs.User.Id != this._client.CurrentUser.Id) { req.RemoveReaction(eventargs.Emoji, eventargs.User); } } } return(Task.CompletedTask); }
private async Task DeathGame_StartMsg_MessageReactionRemoved(MessageReactionRemoveEventArgs e) { if (e.User.IsBot) { return; } if (WatchedGameMessages.Contains(e.Message) && DeathGames.ContainsKey(e.Guild.Id)) { var dg = DeathGames[e.Guild.Id]; var part = dg.participants.First(x => x.Id == e.User.Id); var pchannel = e.Guild.GetChannel(SettingsManager.GetGuildSettings(e.Guild).FMasterChannelId); await pchannel.SendMessageAsync($"Se ha ido {part.Name} ({e.User.Username}#{e.User.Discriminator}) del juego activo."); dg.participants.Remove(part); } }
async Task HandleReactionRemove(MessageReactionRemoveEventArgs eventargs) { await Task.Yield(); foreach (var req in _requests) { // match message if (req._message.Id == eventargs.Message.Id && req._message.ChannelId == eventargs.Channel.Id) { if (eventargs.User.Id != _client.CurrentUser.Id) { req.RemoveReaction(eventargs.Emoji, eventargs.User); } } } }
public async Task HandleRemoveAsync(MessageReactionRemoveEventArgs eventArgs) { using IServiceScope scope = _provider.CreateScope(); foreach (Type reactionHandlerType in _reactionsHandlers) { IReactionHandler handler = scope.ServiceProvider.GetService(reactionHandlerType) as IReactionHandler ?? throw new ArgumentOutOfRangeException(); var shouldStop = await handler.HandleRemoveAsync(eventArgs).ConfigureAwait(false); if (shouldStop == IReactionHandler.Result.Stop) { return; } } }
private Task Client_MessageReactionRemoved(DiscordClient sender, MessageReactionRemoveEventArgs e) { if (e.Channel != roles) { return(Task.CompletedTask); } String emojiname = e.Emoji.GetDiscordName(); if (ReactionRole.ContainsKey(e.Message.Id)) { Dictionary <string, ulong> auxDict = ReactionRole[e.Message.Id]; DiscordMember member = (DiscordMember)e.User; member.RevokeRoleAsync(languageServer.GetRole(auxDict[emojiname])); } return(Task.CompletedTask); }