Example #1
0
 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");
     }
 }
Example #2
0
        // 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
                });
            }
        }
Example #4
0
        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]));
        }
Example #5
0
        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);
        }
Example #6
0
File: YuiShard.cs Project: HKGx/Yui
        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;
                }
            }
        }
Example #7
0
 public MessageReactionEventArgs(MessageReactionRemoveEventArgs e)
 {
     Message = e.Message;
     Channel = e.Channel;
     User    = e.User;
     Emoji   = e.Emoji;
 }
Example #8
0
        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);
        }
Example #11
0
        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();
                }
            }
        }
Example #12
0
        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));
        }
Example #13
0
 private async Task OnMessageReactionRemoved(MessageReactionRemoveEventArgs e)
 {
     if (MessageReactionRemoved != null)
     {
         await MessageReactionRemoved(e);
     }
 }
Example #14
0
 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);
     }
 }
Example #16
0
 /// <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));
     }
 }
Example #17
0
 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);
     }
 }
Example #18
0
        protected virtual void ReactionRemoved(MessageReactionRemoveEventArgs e)
        {
            if (!CheckRequirements(e.Channel, e.Message))
            {
                return;
            }

            OnReactionRemoved?.Invoke(e);
        }
Example #19
0
        private Task OnReactionRemoved(MessageReactionRemoveEventArgs e)
        {
            if (e.Message.Id != Message.Id)
            {
                return(Task.CompletedTask);
            }

            UpdateReactions();
            return(Task.CompletedTask);
        }
Example #20
0
        /* 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());
                }
            }
        }
Example #21
0
        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);
        }
Example #22
0
 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);
 }
Example #23
0
        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;
        }
Example #24
0
        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");
                }
            }
        }
Example #26
0
 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);
 }
Example #27
0
        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);
            }
        }
Example #28
0
        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);
                    }
                }
            }
        }
Example #29
0
        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;
                }
            }
        }
Example #30
0
        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);
        }