//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();
