//Is the majority of the Guild for yes? public async Task <bool> HasMajority() { //Get total users and all voters var totalUsers = await _guild.GetUsersAsync(); var yesUser = await _message.GetReactionUsersAsync(Information.VotekickYes); var noUser = await _message.GetReactionUsersAsync(Information.VotekickNo); int yes = yesUser.Count; int no = noUser.Count; int online = totalUsers.Count(u => u.VoiceChannel != null); //more than half of online users voted yes AND //only half of the yes-voters voted for no if (yes > online / 2 && yes > no * 2) { //check if admin voted no -> dismiss vote if (noUser.Any(iuser => CheckIfAdmin(iuser as IGuildUser))) { await _message.Channel.SendMessageAsync( $"An admin voted _no_, _{Helper.GetName(_user)}_ cannot be kicked!"); return(false); } return(true); } return(false); }
async Task <bool> FixRaidMessageAfterLoad(SocketGuild guild, IUserMessage message) { var raidInfo = ParseRaidInfo(message); if (raidInfo == null) { return(false); } logger.LogInformation($"Updating raid message '{message.Id}'"); raidStorageService.AddRaid(guild.Id, message.Channel.Id, message.Id, raidInfo); // Adjust user count var allUsersWithThumbsUp = await message.GetReactionUsersAsync(Emojis.ThumbsUp, ReactionUsersLimit).FlattenAsync(); var usersWithThumbsUp = allUsersWithThumbsUp .Where(t => !t.IsBot) .Select(t => guild.GetUser(t.Id)) .Where(t => t != null); foreach (var user in usersWithThumbsUp) { raidInfo.Players[user.Id] = userService.GetPlayer(guild.GetUser(user.Id)); } // Extra players for (int i = 0; i < Emojis.KeycapDigits.Length; i++) { var emoji = Emojis.KeycapDigits[i]; var usersWithKeycapReaction = await message.GetReactionUsersAsync(emoji, ReactionUsersLimit).FlattenAsync(); foreach (var user in usersWithKeycapReaction.Where(t => !t.IsBot)) { raidInfo.ExtraPlayers.Add((user.Id, ExtraPlayerKeycapDigitToCount(emoji.Name))); } } await message.ModifyAsync(t => { t.Content = string.Empty; t.Embed = ToEmbed(raidInfo); }); var allReactions = message.Reactions; var invalidReactions = allReactions.Where(t => !IsValidReactionEmote(t.Key.Name)).ToList(); // Remove invalid reactions foreach (var react in invalidReactions) { var users = await message.GetReactionUsersAsync(react.Key, ReactionUsersLimit, retryOptions).FlattenAsync(); foreach (var user in users) { await message.RemoveReactionAsync(react.Key, user, retryOptions); } } return(true); }
public async Task ExecuteGiveaway(GiveawayEntry entry, ulong serverId) { IGuild guild = await m_client.GetGuildAsync(serverId); ServerEntry server = m_db.GetServerEntry(serverId); ITextChannel channel = await guild.GetTextChannelAsync(entry.ChannelId); IUserMessage message = await channel.GetMessageAsync(entry.ReactionMessageId) as IUserMessage; var asyncparticipants = message.GetReactionUsersAsync(new Emoji(server.GiveawayReactionEmote), int.MaxValue); IEnumerable <IUser> users = await asyncparticipants.FlattenAsync(); List <IUser> participants = users.Where(user => user.Id != m_client.CurrentUser.Id).ToList(); List <IUser> winners = new List <IUser>(); if (participants.Count <= 0) { await channel.SendMessageAsync($"No one participated for {entry.Content}"); } else { for (int i = 0; i < entry.Count; i++) { IUser winner; do { winner = participants[m_random.Next(0, participants.Count)]; } while(winners.Contains(winner) && entry.Count < participants.Count); winners.Add(winner); } await channel.SendMessageAsync($"{string.Join(' ', winners.Select(winner => winner.Mention))} won **{entry.Content}**!"); } }
private async Task <bool> CanPostponeRemindAsync(IUserMessage message, SocketReaction reaction) { try { if ( message.Embeds.Count != 1 || reaction.Emote is not Emoji emoji || !ReminderDefinitions.AllHourEmojis.Contains(emoji) || !reaction.User.IsSpecified || (DateTime.UtcNow - message.CreatedAt).TotalHours >= 24.0d ) { return(false); } var users = await message.GetReactionUsersAsync(emoji, 5).FlattenAsync(); var containsBot = users.Any(o => o.Id == Discord.CurrentUser.Id); var containsUser = users.Any(o => o.Id == reaction.User.Value.Id); return(containsBot && containsUser); } catch (HttpException ex) when(ex.DiscordCode != null && ex.DiscordCode == (int)DiscordJsonCodes.UnknownMessage) { return(false); } }
public async Task WriteMessage(ISocketMessageChannel channel, IUserMessage message, EventsWithCount @event) { var messageContents = $"**Confirmation Check for {@event.Name}!{Environment.NewLine}" + $"Please confirm your attendance by reacting to this message.**{Environment.NewLine}{Environment.NewLine}"; if ([email protected] && [email protected]) { messageContents += $"You can still sign up to this event by typing `!event join {@event.DisplayName}`{Environment.NewLine}{Environment.NewLine}"; } var signUps = await _eventSignups.GetAllSignupsForEvent(@event); var confirmed = new List <IUser>(); foreach (var reaction in message.Reactions) { var reactors = await message.GetReactionUsersAsync(reaction.Key, 999).FlattenAsync(); confirmed.AddRange(reactors); } confirmed = confirmed.Distinct(new UserEqualityComparer()).Where(confirmed => signUps.Any(sup => sup.UserId == confirmed.Id.ToString())).ToList(); var unconfirmed = signUps.Where(signUp => !confirmed.Any(con => con.Id.ToString() == signUp.UserId)); var channelUsers = await channel.GetUsersAsync().FlattenAsync(); var unconfirmedUsers = unconfirmed.Select(u => channelUsers.FirstOrDefault(cu => cu.Id.ToString() == u.UserId)).ToList(); messageContents += $"**Confirmed:**{Environment.NewLine}" + $"{string.Join(Environment.NewLine, confirmed.Select(con => con?.Mention ?? "Unknown User"))}{Environment.NewLine}"; messageContents += $"**Unconfirmed:**{Environment.NewLine}" + $"{string.Join(Environment.NewLine, unconfirmedUsers.Select(con => con?.Mention ?? "Unknown User"))}{Environment.NewLine}"; await message.ModifyAsync((msg) => msg.Content = messageContents); }
public override async Task Execute(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction) { await base.Execute(message, channel, reaction); using (var db = new Database()) { if (this.TriggeredThreshold) { var currentStarReaction = message.Reactions.Where(re => re.Key.Name == reaction.Emote.Name).DefaultIfEmpty().First(); var reactions = message.GetReactionUsersAsync(Global.OnePlusEmote.STAR, currentStarReaction.Value.ReactionCount); await reactions.ForEachAsync(collection => { foreach (var user in collection) { var starerRelation = new StarboardPostRelation(); starerRelation.UserId = user.Id; starerRelation.MessageId = message.Id; db.StarboardPostRelations.Add(starerRelation); } }); } else if (this.RelationAdded) { var starerRelation = new StarboardPostRelation(); starerRelation.UserId = reaction.UserId; starerRelation.MessageId = message.Id; db.StarboardPostRelations.Add(starerRelation); } db.SaveChanges(); } }
private void OnRedisEvent(RedisChannel arg1, RedisValue arg2) { var name = arg2.ToString().Split(':'); if (name.Length == 2 && name[0] == "giveaway") { var id = long.Parse(name[1]); // Get the giveaway from the database var connection = _sqlDatabase.GetDbConnection(); // Query the database connection.QueryAsync(GetGiveawayById, new { id }).ContinueWith(async(task) => { try { // Get the giveaway from the query result var result = task.Result; // If the giveaway exists in the database if (result.Any()) { // We get the first giveaway var giveaway = result.First(); // Try to get the channel from the discord client SocketTextChannel channel = (SocketTextChannel)_discord.GetChannel((ulong)giveaway.channel); // If the channel exists if (channel != null) { // Get the giveaway's message IUserMessage message = (IUserMessage)await channel.GetMessageAsync((ulong)giveaway.message); if (message != null) { var emote = new Emoji("🎉"); var reactions = await message.GetReactionUsersAsync(emote, 9999).FlattenAsync(); var win = new List <IUser>(); var count = reactions.Count() - reactions.Count(x => x.IsBot); var wC = giveaway.winners; if (wC > count) { wC = count; } while (wC != 0) { var winner = reactions.ElementAt(_random.Next(count)); while (win.Any(x => x.Id == winner.Id) || winner.IsBot) { winner = reactions.ElementAt(_random.Next(count)); } win.Add(winner); wC--; } await channel.SendMessageAsync(string.Join(",", win.Select(x => x.Mention)) + " won `" + giveaway.price + "`"); await message.ModifyAsync(x => x.Embed = message.Embeds.First().ToEmbedBuilder().WithDescription($"Finished ! {string.Join(",", win.Select(x => x.Mention))}").Build()); } } } } catch (Exception) { /*Ignore exceptions in a redis method */ } }); } }
private void RunSafari(EmbedBuilder embed, IUserMessage msg, Card newCard, SafariImage pokeImage, ICharacterInfo character, ITextChannel trashChannel) { _ = Task.Run(async() => { try { await Task.Delay(TimeSpan.FromMinutes(5)); var usersReacted = await msg.GetReactionUsersAsync(ClaimEmote, 300).FlattenAsync(); var users = usersReacted.ToList(); IUser winner = null; using (var db = new Database.UserContext(_config)) { var watch = Stopwatch.StartNew(); while (winner == null) { if (watch.ElapsedMilliseconds > 60000) { throw new Exception("Timeout"); } if (users.Count < 1) { embed.Description = $"Na polowanie nie stawił się żaden łowca!"; await msg.ModifyAsync(x => x.Embed = embed.Build()); return; } var selected = Fun.GetOneRandomFrom(users); var dUser = await db.GetCachedFullUserAsync(selected.Id); if (dUser != null) { if (!dUser.IsBlacklisted) { winner = selected; } } else { users.Remove(selected); } } } var exe = GetSafariExe(embed, msg, newCard, pokeImage, character, trashChannel, winner); await _executor.TryAdd(exe, TimeSpan.FromSeconds(1)); await msg.RemoveAllReactionsAsync(); } catch (Exception ex) { _logger.Log($"In Safari: {ex}"); await msg.ModifyAsync(x => x.Embed = "Karta uciekła!".ToEmbedMessage(EMType.Error).Build()); await msg.RemoveAllReactionsAsync(); } }); }
private async Task <List <string> > GetAttendeesAsync(IUserMessage hostMessage, int maxAttendees) { var attendeeResult = await hostMessage.GetReactionUsersAsync(_joinEmote, maxAttendees + 1).ToListAsync(); var attendees = attendeeResult.SelectMany(u => u).Where(u => !u.IsBot).Select(u => u.Mention).ToList(); return(attendees); }
/// <summary> /// Gets every unique user who has reacted to the message, based upon every /// reaction added that qualifies. /// </summary> private async Task <IEnumerable <IUser> > GetReactionUsers(IUserMessage message) { IEnumerable <IUser> allUsers = Array.Empty <IUser>(); foreach (var reaction in message.Reactions.Keys) { if (!_emoteQualifier(reaction)) { continue; } allUsers = allUsers .Concat(await message.GetReactionUsersAsync(reaction, 1000).FlattenAsync()); } // order the users so that when we skip over users things are fine var reactors = allUsers.Distinct(new UserIdEqualityComparer()).OrderBy(user => user.Id).ToArray(); // bodged omega hackjob solution to support emote disqualifiers if (_emoteDisqualifier != null) { IEnumerable <IUser> allDisqualifiers = Array.Empty <IUser>(); foreach (var reaction in message.Reactions.Keys) { if (!_emoteDisqualifier(reaction)) { continue; } allDisqualifiers = allDisqualifiers .Concat(await message.GetReactionUsersAsync(reaction, 1000).FlattenAsync()); } var disqualifiers = allDisqualifiers.Distinct(new UserIdEqualityComparer()) .OrderBy(user => user.Id).ToArray(); // probably a very bad and not great but oh well :D return(reactors.Skip(disqualifiers.Length)); } else { return(reactors); } }
/// <inheritdoc /> public async Task <int> GetReactionCount(IUserMessage message, IEmote emote) { var reactionUsers = await message .GetReactionUsersAsync(emote, 100) .FlattenAsync(); //Ignore author reaction when counting stars return(reactionUsers.Count(user => user.Id != message.Author.Id)); }
protected static async Task <EmbedBuilder> AddVotesAsync(IGuild guild, EmbedBuilder builder, IUserMessage message) { var voteUsers = (await Task.WhenAll(message.Reactions.Keys .Select(async emoji => new { emoji, users = await message.GetReactionUsersAsync(emoji, 1000).FlattenAsync() }))) .Select(kv => new { kv.emoji, users = kv.users .Select(user => guild.GetUserAsync(user.Id, CacheMode.CacheOnly).Result) .Where(user => user != null) .ToList() }) .Where(kv => kv.users.Any(u => u.IsBot || u.IsStaffOrConsultant())) .ToDictionary(kv => kv.emoji, kv => kv.users); var scoreUsers = (await Database.UNSAFE_GetScoreUsers(voteUsers.Values .SelectMany(x => x) .Select(a => a.Id))) .ToDictionary(u => u.UserId, u => u); var getScore = new Func <IGuildUser, ScoreData>(user => { if (scoreUsers.TryGetValue(user.Id, out var value)) { return(value.ScoreData); } return(new ScoreData()); }); var formatting = new Func <IGuildUser, ScoreData, string>((user, score) => { var format = user.IsStaffOrConsultant() ? "__" : ""; return(format + user.Username.DiscordEscape() + "#" + user.Discriminator + format + " (" + score.ShortBaseScoreString + ")"); }); foreach (var kv in voteUsers) { var reacters = kv.Value.Where(user => !user.IsBot) .Select(user => new { user, score = getScore(user) }) .OrderByDescending(userData => userData.score.BaseScoreLevel) .ThenByDescending(userData => userData.user.IsStaffOrConsultant()) .ThenBy(userData => userData.user.Username) .Select(userData => new { formatted = formatting(userData.user, userData.score), userData.score }) .ToList(); builder.AddField( $"{kv.Key} **(Votes: {reacters.Count}, Sum of Scores: {reacters.Sum(a => a.score.BaseScoreLevel).ToString("F1", CultureInfo.InvariantCulture)})**", reacters.Count == 0 ? "Nobody" : string.Join(", ", reacters.Select(a => a.formatted))); } return(builder); }
private async Task updateMessage(IUserMessage message) { if (!updating.ContainsKey(message.Id)) { updating.Add(message.Id, false); } if (!updating[message.Id]) { updating[message.Id] = true; await Task.Delay(10000); updating[message.Id] = false; var e = message.Embeds.First().ToEmbedBuilder(); e.Color = new Color(100, 100, 0); var participants = message.GetReactionUsersAsync(new Emoji("✅"), message.Reactions[new Emoji("✅")].ReactionCount).FlattenAsync().Result.Where(x => !x.IsBot); var participantsCount = participants.Count(); foreach (EmbedFieldBuilder field in e.Fields) { if (field.Name.Equals("Participants")) { field.Value = participantsCount; } else { int.TryParse(message.Embeds.First().Title.Split("x")[0], out int winnerCount); if (winnerCount == 0) { winnerCount = 1; } if (winnerCount > participantsCount) { winnerCount = participantsCount; } double probability = 1; if (participantsCount != 0) { probability = (1.0 / participantsCount) * winnerCount; } field.Value = Math.Round(probability * 100, 2) + "%"; } } await message.ModifyAsync(x => { x.Embed = e.Build(); }); } }
private async Task ResetReactionsIfNecessary(Workshop currentWorkshop, Emoji thumbsUpEmote, Workshop dbWorkshop, IUserMessage message) { if (dbWorkshop == null) { return; } if (!WorkshopHelpers.TimeHasChanged(dbWorkshop, currentWorkshop)) { return; } var hadOneUser = false; var reactedUsers = message.GetReactionUsersAsync(thumbsUpEmote, 1000) .SelectMany(x => x.ToAsyncEnumerable()) .Where(x => !x.IsBot && x.Id != _discordClient.CurrentUser.Id); await foreach (var reactedUser in reactedUsers) { hadOneUser = true; // Notify user that time has changed var affectedTimes = new string[] { !WorkshopHelpers.BeginTimeChanged(dbWorkshop, currentWorkshop) ? string.Empty : "Startzeit", !WorkshopHelpers.EndTimeChanged(dbWorkshop, currentWorkshop) ? string.Empty : "Endzeit" }.Where(x => !string.IsNullOrEmpty(x)); var affectedTimeString = string.Join(" und ", affectedTimes); try { await reactedUser.SendMessageAsync ( $"Die {affectedTimeString} vom Workshop **{currentWorkshop.title}** wurde geändert. \n" + $"Er beginnt um **{currentWorkshop.begintime}** und endet um {currentWorkshop.endtime}.:alarm_clock:\n" + $"Deshalb wurde deine Benachrichtigung deaktiviert. Bitte reagiere erneut mit \U0001F44D auf die Nachricht am Server, damit du rechtzeitig erinnert wirst!" ); } catch (Exception) { //Ignore } } if (hadOneUser) { await message.RemoveAllReactionsAsync(); await message.AddReactionAsync(thumbsUpEmote); } }
public static async Task <IReadOnlyCollection <IUser> > PaginateReactionUsersAsync(this IUserMessage message, IEmote emote, RequestOptions options = null) { var builder = new List <IUser>(); ulong?lastUserID = null; for (int limit = 100; limit < message.Reactions.Count; limit += 100) { var users = await message.GetReactionUsersAsync(emote, 100, lastUserID); lastUserID = users.OrderByDescending(user => user.Id).First().Id; builder.AddRange(users); } return(new ReadOnlyCollection <IUser>(builder)); }
public static async Task DeleteAllReactionsWithEmote(IUserMessage message, IEmote emote) { if (message.Reactions.ContainsKey(emote)) { await using (var usersEnumerator = message.GetReactionUsersAsync(emote, int.MaxValue).GetAsyncEnumerator()) { while (await usersEnumerator.MoveNextAsync()) { foreach (IUser user in usersEnumerator.Current) { await message.RemoveReactionAsync(emote, user); } } } } }
private async Task <ulong> _getReviewIdFromReactionAsync(IUserMessage message, IEmote reaction) { if (!message.Reactions.ContainsKey(reaction)) { return(0); } foreach (IUser user in await message.GetReactionUsersAsync(reaction, 15).FlattenAsync()) { if (_userIsReviewer(user)) { return(user.Id); } } return(0); }
public async Task RemoveRoleButtonLinkAsync(ulong guildID, ulong messageID, ulong roleID) { RoleButtonLink link = await dbContext.RoleButtonLinks .AsQueryable() .SingleOrDefaultAsync(x => x.GuildID == guildID && x.MessageID == messageID && x.RoleID == roleID) .ConfigureAwait(false); if (link == null) { return; } _ = dbContext.RoleButtonLinks.Remove(link); _ = await dbContext.SaveChangesAsync().ConfigureAwait(false); SocketGuild guild = discordClient.GetGuild(guildID); if (guild == null) { return; } IUserMessage msg = await GetMessageAsync(guild, messageID).ConfigureAwait(false); if (msg == null) { return; } IEmote emote = guild.Emotes.FirstOrDefault(x => link.EmoteString.Contains(x.Name, StringComparison.Ordinal)) ?? new Emoji(link.EmoteString) as IEmote; if (emote == null) { return; } //TODO: change to explicit type once Discord.Net dependency on IAsyncEnumerable is fixed var reactedUsers = msg.GetReactionUsersAsync(emote, 100); await reactedUsers.ForEachAsync(async users => { foreach (IUser user in users) { await msg.RemoveReactionAsync(emote, user).ConfigureAwait(false); } }).ConfigureAwait(false); }
private async Task TryLearn([NotNull] IUserMessage message, [NotNull] IReaction reaction, Sentiment sentiment) { var gc = (SocketGuildChannel)message.Channel; var g = gc.Guild; var users = (await(message.GetReactionUsersAsync(reaction.Emote, 128).Flatten().ToArray())) //Get users who reacted .Select(u => u as IGuildUser ?? g.GetUser(u.Id)) //Convert them to guild users .Where(u => u != null) .GroupBy(a => a.Id) //GroupBy ID to deduplicate users who reacted multiple times .Select(a => a.First()) .ToArray(); if (users.Length >= 3 || users.Any(IsTeacher)) { await _sentiment.Teach(message.Content, sentiment); } }
private async Task <int> GetTrueStarCount(IUserMessage message, KeyValuePair <IEmote, ReactionMetadata> starReaction) { var reactions = message.GetReactionUsersAsync(Global.OnePlusEmote.STAR, starReaction.Value.ReactionCount); var validReactions = 0; await reactions.ForEachAsync(collection => { foreach (var user in collection) { if (user.Id != message.Author.Id) { validReactions += 1; } } }); return(validReactions); }
private void CheckReactionUsers(IUserMessage gameMessage, Dictionary <string, string> newPlayersNickNameLookup) { int eventReactionsCount = newPlayersNickNameLookup.Count; int badGetReactions = 0; int addedGetReactions = 0; int existingGetReactions = 0; int getReactionsCount = 0; var result = gameMessage.GetReactionUsersAsync(ReactionToUse, DiscordConfig.MaxUsersPerBatch).GetAwaiter().GetResult(); if (result != null) { Dictionary <string, string> playersUserNameLookup = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> keyValuePair in newPlayersNickNameLookup) { playersUserNameLookup[keyValuePair.Value] = keyValuePair.Key; } getReactionsCount = result.Count; foreach (IUser user in result) { if (playersUserNameLookup.ContainsKey(user.Username) == false) { SocketGuildUser userLookup = _channel.GetUserAsync(user.Id).GetAwaiter().GetResult() as SocketGuildUser; if (userLookup != null) { newPlayersNickNameLookup[userLookup.Nickname ?? userLookup.Username] = userLookup.Username; addedGetReactions++; } else { badGetReactions++; } } else { existingGetReactions++; } } } Logger.Log($"RunGame - GetReactionsReturned: {getReactionsCount} EventReactions: {eventReactionsCount} BadUsers: {badGetReactions} AddedUsers: {addedGetReactions} ExistingUsers: {existingGetReactions} TotalPlayers: {newPlayersNickNameLookup.Count}"); }
private async Task TryLearn([NotNull] IUserMessage message, [NotNull] IReaction reaction, Sentiment sentiment) { //Early exit if channel is not a guild channel if (!(message.Channel is SocketGuildChannel gc)) { return; } var g = gc.Guild; //Get guild users who reacted to the message var users = await message.GetReactionUsersAsync(reaction.Emote, 128).Flatten() .Select(u => u as IGuildUser ?? g.GetUser(u.Id)) .Where(u => u != null) .Distinct() .ToArray(); if (users.Length >= 3 || users.Any(IsTeacher)) { await _sentiment.Teach(message.Content, sentiment); } }
public async Task <(IEmote[], string)> ConstructAsync(SocketCommandContext context, IUserMessage message) { Emoji emote = new Emoji("✅"); await message.AddReactionAsync(emote); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); var reactionCount = 0; IList <IEmote> emotes = new List <IEmote>(); do { if (stopwatch.ElapsedMilliseconds > 60 * 1000) { stopwatch.Stop(); return(emotes.ToArray(), "Time elapsed. Please type the command again."); } await Task.Delay(1000); reactionCount = (await message.GetReactionUsersAsync(emote, 10).FirstAsync()).Count(u => !u.IsBot); }while (reactionCount == 0); var newMessage = await context.Channel.GetMessageAsync(message.Id); StringBuilder replyMsg = new StringBuilder($"React to give yourself a role.{Environment.NewLine}"); foreach (var reaction in newMessage.Reactions) { if (reaction.Key.Name == "✅") { continue; } replyMsg.Append(reaction.Key).Append(" **:** ").Append(reaction.Key.Name).Append(Environment.NewLine); emotes.Add(reaction.Key); } return(emotes.ToArray(), replyMsg.ToString()); }
private async Task OnReactionAdded(Discord.Cacheable <Discord.IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction) { string segIndex = ""; messageMarker messageMarker = messageMarkers[channel.Id]; if (reaction.User.Value.IsBot || message.Id != messageMarker.messageId) { return; } Adventure adventure = adventures[messageMarker.adventureName]; AdventureSegment segment = adventure.segments[messageMarker.segIndex]; foreach (AdventureChoice choice in segment.choices) { Emoji emoji = new Emoji(choice.emote); IUserMessage msg = await message.GetOrDownloadAsync(); if ((await msg.GetReactionUsersAsync(emoji, 5).FlattenAsync()).Count() > 1) { segIndex = choice.target; } } if (adventure.segments[segIndex].choices.Count() > 0) { IUserMessage newmsg = await SendSegmentMessage(channel, messageMarker.adventureName, segIndex); messageMarkers[channel.Id] = new messageMarker(newmsg.Id, messageMarker.adventureName, segIndex); } else { IncrementPlays(messageMarker.adventureName); await SendEndingMessage(channel, messageMarker.adventureName, segIndex); messageMarkers.Remove(channel.Id); } }
//TODO A terme implémentera le system d'Actions lié => dossier Reactions public async Task Guild_Message_ReactionAdded(Cacheable <IUserMessage, ulong> cachedMessage, ISocketMessageChannel channel, SocketReaction reaction) { try { IUserMessage message = channel.GetMessageAsync(cachedMessage.Id).Result as IUserMessage; if (reaction.User.Value.IsAdmin()) { IUserMessage nsfwMessage = ReactionUtils.IsThisNsfwInProgress(message); if (nsfwMessage != null) { if (reaction.Emote.Equals(EmoteManager.CheckMark)) { await message.DeleteAsync(); ReactionUtils.NsfwProcessing(nsfwMessage); ReactionUtils.RemoveNsfwMessage(message); } else if (reaction.Emote.Equals(EmoteManager.CrossMark)) { await message.DeleteAsync(); await nsfwMessage.RemoveAllReactionsAsync(); ReactionUtils.RemoveNsfwMessage(message); } } else if (channel.Id == Channels.Musique.Id && reaction.Emote.Equals(EmoteManager.CrossMark)) { string result = DataManager.database.removeMusic(message.Content.GetYtLink()); if (result == string.Empty) { await message.RemoveAllReactionsAsync(); await message.AddReactionAsync(EmoteManager.Skull); await Channels.Debugs.SendMessageAsync("Message n°" + reaction.MessageId + " deleted from musique database. (" + message.Content + ")"); } } else if (reaction.Emote.Equals(EmoteManager.Nsfw)) { ReactionUtils.NsfwProcessing(message); } } else { if (reaction.Emote.Equals(EmoteManager.Nsfw)) { int result = 0; var reactedUsers = await message.GetReactionUsersAsync(EmoteManager.Nsfw, 100).FlattenAsync(); IUser user = null; using (IEnumerator <IUser> enumerator = reactedUsers.GetEnumerator()) { while (enumerator.MoveNext()) { if (result == 0) { user = enumerator.Current; } result++; } } if (result == 1) { await message.AddReactionAsync(EmoteManager.Nsfw); Embed embed = message.Quote(reaction.User.Value); IUserMessage messageSent = null; if (embed != null) { messageSent = await message.Channel.SendMessageAsync("<@&328899154887835678> Is this NSFW ? *reported by " + user.Mention + "*", false, embed); } else { messageSent = await message.Channel.SendMessageAsync("<@&328899154887835678> Is this NSFW ? *reported by " + user.Mention + "*"); } await messageSent.AddReactionsAsync(new IEmote[] { EmoteManager.CheckMark, EmoteManager.CrossMark }); DataManager.nsfw_content_inprocess.Add(messageSent, message); } } } } catch (Exception e) { e.DisplayException(System.Reflection.MethodBase.GetCurrentMethod().ToString()); } }
private async Task DrawGiveaway(ulong userId, IUserMessage message) { if (userId.Equals(Giveaways[message.Channel.Id][message.Id].First())) { var limit = message.Reactions[new Emoji("✅")].ReactionCount; var participants = message.GetReactionUsersAsync(new Emoji("✅"), limit).FlattenAsync().Result.Where(x => !x.IsBot); await Program.ReactionHandler.ClearHandler(message); int.TryParse(message.Embeds.First().Title.Split("x")[0], out int winnerCount); string winnerDescription = ""; //Remove any duplicates to race-conditions var participantsDraw = participants.ToHashSet().Select(x => x.Id).ToList(); if (winnerCount <= 0) { winnerCount = 1; } if (winnerCount > participantsDraw.Count) { winnerCount = participantsDraw.Count; } for (int i = 0; i < winnerCount; i++) { var index = StaticBase.ran.Next(0, participantsDraw.Count); ulong winnerId = participantsDraw[index]; IUser winner = await message.Channel.GetUserAsync(winnerId); winnerDescription += $"{winner.Mention} won the " + $"`{message.Embeds.First().Title}`\n"; participantsDraw.RemoveAt(index); } if (string.IsNullOrEmpty(winnerDescription)) { winnerDescription = "No winners could be drawn."; } var winners = winnerDescription.Split("\n"); var messageText = ""; for (int i = 0; i < winners.Count(); i++) { if (messageText.Count() + winners[i].Count() <= 2000) { messageText += winners[i] + "\n"; } else { await message.Channel.SendMessageAsync(messageText); messageText = ""; } } if (messageText.Count() > 0) { await message.Channel.SendMessageAsync(messageText); } var embed = message.Embeds.First().ToEmbedBuilder().WithDescription("Giveaway has ended"); await message.ModifyAsync(x => x.Embed = embed.Build()); if (Giveaways[message.Channel.Id].Count == 1) { Giveaways.Remove(message.Channel.Id); await RemoveFromDBAsync(message.Channel.Id); } else { Giveaways[message.Channel.Id].Remove(message.Id); await UpdateDBAsync(message.Channel.Id); } } }
private static async Task CheckReactions(IUserMessage message) { List <ReactionRole> rrs; lock (Data.ReactionRoles){ rrs = new List <ReactionRole>(Data.ReactionRoles); //Create a copy of the ReactionRole list and use that copy } foreach (ReactionRole rr in rrs) { if (message.Id != rr.messageID) { continue; } Debug.Log("Checking reactions to message(" + rr.messageID + ")...", Debug.Verbosity.Verbose); var guild = _client.GetGuild(rr.guildID); if (guild == null) { Debug.Log("Could not get guild by ID!", Debug.Verbosity.Error); continue; } Emoji emoji = new Emoji(rr.emote); if (emoji == null) { Debug.Log("Could not create emoji [" + rr.emote + "]!", Debug.Verbosity.Error); continue; } var usersWithReactions = await message.GetReactionUsersAsync(emoji, 100).FlattenAsync(); List <ulong> userIDs = new List <ulong>(); foreach (var u in usersWithReactions) { userIDs.Add(u.Id); } foreach (var u in guild.Users) { if (u.IsBot || u.IsWebhook) { continue; //Don't mess with bot roles } SocketRole role = guild.GetRole(rr.role); if (role == null) { Debug.Log("Could not find role with ID " + rr.role + "!", Debug.Verbosity.Error); break; } if (userIDs.Contains(u.Id) && !u.Roles.Contains(role)) { string debugText = "Adding " + role.Name + " role to user " + u.Username; if (u.Nickname != null && u.Nickname.Length > 0) { debugText += " (" + u.Nickname + ")"; } Debug.Log(debugText); await u.AddRoleAsync(role); } else if (!userIDs.Contains(u.Id) && u.Roles.Contains(guild.GetRole(rr.role))) { string debugText = "Removing " + role.Name + " role from user " + u.Username; if (u.Nickname != null && u.Nickname.Length > 0) { debugText += " (" + u.Nickname + ")"; } Debug.Log(debugText); await u.RemoveRoleAsync(role); } } } }
public static List <Tuple <IUser, Emoji> > GetReactions(IUserMessage msg, List <Emoji> emojis, double secondInterval) { Stopwatch timer = new Stopwatch(); List <Tuple <IUser, Emoji> > reactionTuples = new List <Tuple <IUser, Emoji> >(); timer.Start(); Console.WriteLine("starting"); while (timer.Elapsed.TotalSeconds < secondInterval) { foreach (Emoji emoji in emojis) { IReadOnlyCollection <IUser> users = (IReadOnlyCollection <IUser>)(msg.GetReactionUsersAsync(emoji).Result); for (int i = 0; i < users.Count(); i++) { var u = users.ElementAt(i); bool found = false; foreach (var tuple in reactionTuples) { if (tuple.Item1.Id == u.Id) { found = true; continue; } } if (!found) { reactionTuples.Add(new Tuple <IUser, Emoji>(u, emoji)); } } } //Console.WriteLine(timer.Elapsed.TotalSeconds + " < " + secondInterval + " returns " + (timer.Elapsed.TotalSeconds < secondInterval).ToString()); } return(reactionTuples); }
private async Task <int> GetReactionCount(IUserMessage msg, IEmote emote) { var reactions = await msg.GetReactionUsersAsync(emote, 100).FlattenAsync().ConfigureAwait(false); return(reactions.Count(u => u.Id != msg.Author.Id)); }
private async Task <ImmutableArray <IUser> > GetReactorsAsync(IUserMessage message) => (await message.GetReactionUsersAsync(_giveawayEmoji, int.MaxValue) .FlattenAsync()) .Where(y => !y.IsBot) .ToImmutableArray();