private static async Task ClientOnMessageReactionAdded(MessageReactionAddEventArgs e, Game game)
{
var present = false;
foreach (var personnage in game.PersonnagesList.FindAll(p => p.Alive))
{
if (e.Emoji == personnage.Emoji)
{
present = true;
}
}
if (!present || (GameBuilder.GetMember(game.Guild, e.User)).Roles.Contains(Global.Roles[CustomRoles.Spectator]))
{
await DailyVotingMessage.DeleteReactionAsync(e.Emoji, e.User);
return;
}
if (!e.User.IsBot && !GameBuilder.GetMember(game.Guild, e.User).Roles.Contains(Global.Roles[CustomRoles.Spectator]))
{
foreach (var otherEmoji in (await game.Guild.GetEmojisAsync()))
{
if (otherEmoji.Name != e.Emoji.Name)
{
await DailyVotingMessage.DeleteReactionAsync(otherEmoji, e.User,
$"{e.User.Username} already voted");
}
}
}
}
private Task _discordClient_MessageReactionAdded(DiscordClient sender, MessageReactionAddEventArgs e)
{
_ = Task.Run(async() =>
{
await _semaphoreLock.WaitAsync();
_semaphoreLock.Release();
if (e.Channel.Id != _textChannel.Id || e.Emoji != _config.FaqRoleEmoji ||
!(e.User is DiscordMember member))
{
return;
}
if (!IsEnabled)
{
if (_faqLockInformed.Contains(member.Id) || member.Roles.Any(x => x.Id == _config.FaqRoleId))
{
return;
}
// Only send the DM once.
_faqLockInformed.Add(member.Id);
await member.SendMessageAsync(embed: new DiscordEmbedBuilder
{
Description =
"The FAQ verification process is temporarily locked, this is most likely due to spam bots joining. Please try again later.",
Color = DiscordColor.Orange
}.Build());
return;
}
// Check that the message reacted to is the last message in the channel
if (_lastMessage.Id == e.Message.Id)
{
// Ignore actions from the bot, or if the user already has the role
if (!member.IsSelf(_discordClient))
{
if (member.Roles.All(x => x.Id != _config.FaqRoleId))
{
var role = _textChannel.Guild.GetRole(_config.FaqRoleId);
await member.GrantRoleAsync(role);
}
if (_lastMessage.IsUserMessage())
{
await _lastMessage.DeleteReactionAsync(_config.FaqRoleEmoji, member);
}
}
}
});
return(Task.CompletedTask);
}
public async Task Background(CommandContext ctx, int?page = null)
{
if (page == null || page <= 0)
{
page = 1;
}
var msgBuilder = new DiscordMessageBuilder()
.WithContent(CustomMethod.GetBackgroundList(ctx, (int)page))
.WithReply(ctx.Message.Id, true);
DiscordMessage TopMessage = await ctx.RespondAsync(msgBuilder);
DiscordEmoji left = DiscordEmoji.FromName(ctx.Client, ":arrow_left:");
DiscordEmoji right = DiscordEmoji.FromName(ctx.Client, ":arrow_right:");
await TopMessage.CreateReactionAsync(left);
await Task.Delay(300).ContinueWith(t => TopMessage.CreateReactionAsync(right));
bool end = false;
do
{
var result = TopMessage.WaitForReactionAsync(ctx.User, TimeSpan.FromSeconds(20));
if (result.Result.TimedOut)
{
end = result.Result.TimedOut;
}
else if (result.Result.Result.Emoji == left)
{
await TopMessage.DeleteReactionAsync(result.Result.Result.Emoji, ctx.User);
if (page > 1)
{
page--;
await TopMessage.ModifyAsync(CustomMethod.GetBackgroundList(ctx, (int)page));
}
}
else if (result.Result.Result.Emoji == right)
{
await TopMessage.DeleteReactionAsync(result.Result.Result.Emoji, ctx.User);
page++;
try
{
await TopMessage.ModifyAsync(CustomMethod.GetBackgroundList(ctx, (int)page));
}
catch (Exception)
{
page--;
}
}
} while (!end);
await TopMessage.DeleteAllReactionsAsync();
}
public async Task <bool> DeleteReactionAsync(DiscordMessage message, DiscordUser reactionUser, DiscordEmoji emoji)
{
try
{
await message.DeleteReactionAsync(emoji, reactionUser);
}
catch (UnauthorizedException)
{
var messageContent = message.Content ?? (await message.Channel.GetMessageAsync(message.Id)).Content;
if (messageContent.EndsWith("```", StringComparison.InvariantCultureIgnoreCase))
{
messageContent += "\r\n";
messageContent += "*It seems that I have not enough permissions to do pagination properly. Please check " +
"bot/channel permissions and be sure that I have ability to manage messages.*";
}
_logger.Warn("Can't do pagination due to permissions");
await message.ModifyAsync(messageContent);
return(false);
}
return(true);
}
public async void Derratives(CommandContext ctx, DiscordMessage init, int select, dynamic myresponse, dynamic dresponse)
{
try
{
try { await init.DeleteReactionAsync(DiscordEmoji.FromName(ctx.Client, ":revolving_hearts:"), ctx.Message.Author); }
catch { }
string tumurl = "";
if (myresponse.items[select].pvs.Count != 0)
{
tumurl = myresponse.items[select].pvs[0].thumbUrl;
}
var emim = new DiscordEmbedBuilder
{
Color = new DiscordColor("#68D3D2"),
Title = "Covers & Remixes!"
};
emim.WithThumbnail(tumurl);
string stuff = "";
foreach (var derr in dresponse)
{
stuff += $"**{derr.name} by {derr.artistString}**\n https://vocadb.net/S/" + derr.id + " \n\n";
}
if (stuff.Length > 1950)
{
stuff = "too many please go to https://vocadb.net/S/" + myresponse.items[select].id;
}
emim.WithDescription("Found: \n\n" + stuff);
var end = emim.Build();
await init.ModifyAsync(null, embed : end);
}
catch
{
await ctx.RespondAsync("Error");
}
}
public async Task RemovePreviousReactionsAsync(DiscordUser user, DiscordEmoji currentReaction)
{
var reactions = m_message.Reactions
.Where(x => x.Count > 1 && x.Emoji != currentReaction);
foreach (var reaction in reactions)
{
await m_message.DeleteReactionAsync(reaction.Emoji, user);
}
}
protected async Task AddReactionButton(DiscordEmoji emoji, UIAction pressedAction)
{
await message.CreateReactionAsync(emoji);
Flipper.Bot.MessageReactionAdded += async args =>
{
if (args.Message == message && args.Emoji == emoji && args.User != Flipper.Bot.CurrentUser)
{
var press = pressedAction(args.ToUIActionArgs());
var delete = message.DeleteReactionAsync(emoji, args.User);
await Task.WhenAll(press, delete);
}
};
}
public async void BaseiInfo(CommandContext ctx, DiscordMessage init, int select, dynamic myresponse, dynamic dresponse)
{
try
{
try { await init.DeleteReactionAsync(DiscordEmoji.FromName(ctx.Client, ":pushpin:"), ctx.Message.Author); }
catch { }
string tumurl = "";
if (myresponse.items[select].pvs.Count != 0)
{
tumurl = myresponse.items[select].pvs[0].thumbUrl;
}
var emim = new DiscordEmbedBuilder
{
Color = new DiscordColor("#68D3D2"),
Title = "Results!",
Description = "Entry for " + myresponse.term,
ThumbnailUrl = tumurl
};
emim.AddField("Artist", myresponse.items[select].artistString, true);
emim.AddField("Title", myresponse.items[select].defaultName, true);
emim.AddField("Language", myresponse.items[select].defaultNameLanguage, true);
emim.AddField("Published", myresponse.items[select].publishDate.ToShortDateString(), true);
emim.AddField("Song Type", myresponse.items[select].songType, true);
//emim.AddField("Lyrics", lys);
string pvs = "";
foreach (var pv in myresponse.items[select].pvs)
{
pvs += pv.url + "\n";
}
emim.AddField("PV(s)", pvs, true);
emim.AddField("VocaDB Link", $"https://vocadb.net/S/{myresponse.items[select].id}", true);
emim.AddField("Cover/Remix count", dresponse.Count.ToString(), true);
emim.WithFooter("Requested by " + ctx.Message.Author.Username, ctx.Message.Author.AvatarUrl);
//emim.AddField("Buttons", $"{DiscordEmoji.FromName(ctx.Client, ":pushpin: ")} this\n" +
// $"{DiscordEmoji.FromName(ctx.Client, ":page_facing_up:")} (if available) Lyrics!\n" +
// $"{DiscordEmoji.FromName(ctx.Client, ":movie_camera:")} Watch the PV!\n" +
// $"{DiscordEmoji.FromName(ctx.Client, ":x:")} cancel out, not needed, but its there");
var end = emim.Build();
await init.ModifyAsync(null, embed : end);
}
catch
{
await ctx.RespondAsync("Song not found (Note: In weird cases it finds the song but still returns 0 results, since this crashes the bot, its not showing anything here)");
}
}
public async void PVShowInfo(CommandContext ctx, DiscordMessage init, int select, dynamic myresponse, dynamic dresponse, int yt)
{
try
{
try { await init.DeleteReactionAsync(DiscordEmoji.FromName(ctx.Client, ":movie_camera:"), ctx.Message.Author); }
catch { }
if (yt == -1)
{
yt = 0;
}
await init.ModifyAsync(myresponse.items[select].pvs[yt].url, embed : null);
}
catch
{
await ctx.RespondAsync("If you see this, idk how this can even break, it just changes the message to a link, no fancy embed making involved anyway, tell Speyd3r#3939");
}
}
public async void PVShowInfo(CommandContext ctx, DiscordMessage init, int select, dynamic myresponse, dynamic dresponse, int yt)
{
try
{
try { await init.DeleteReactionAsync(DiscordEmoji.FromName(ctx.Client, ":movie_camera:"), ctx.Message.Author); }
catch { }
if (yt == -1)
{
yt = 0;
}
await init.ModifyAsync(myresponse.items[select].pvs[yt].url, embed : null);
}
catch
{
await ctx.RespondAsync("Something broke that shouldnt break, hmm");
}
}
public async Task OnReactionAdd(MessageReactionAddEventArgs e)
{
if (e.User.Id == user.Id && ValidReactions.Contains(e.Emoji))
{
if (e.Emoji == LeftArrowEmoji)
{
if (CanGoLeftPage)
{
--page;
}
}
else if (e.Emoji == RightArrowEmoji)
{
if (CanGoRightPage)
{
++page;
}
}
else
{
int index = DigitEmojis.ToList().IndexOf(e.Emoji);
var reminder = remindersOnPage[index];
await remindMe.DeleteReminder(reminder);
scopedRemindersCount = scopedReminders.Count();
if (page > 0 && NumberOfRemindersOnPage <= 0)
{
--page;
}
}
timeoutTimer.Stop();
timeoutTimer.Start();
await UpdateMessage();
}
else
{
try {
await message.DeleteReactionAsync(e.Emoji, e.User, "Invalid reaction to reminder list");
} catch (UnauthorizedException) {
remindMe.BotMethods.Log(this, new LogEventArgs {
Message = $"ReminderList tried clearing reactions, but couldn't because it doesn't have permission. The user must clear their own reaction.",
Type = LogType.Warning
});
}
}
}
public async void ManageRole(DiscordMessage message, DiscordChannel channel, DiscordMember member, DiscordEmoji emoji)
{
var guild = await redis.GetAsync <Guild>(RedisKeyNaming.Guild(channel.GuildId));
var reactionCategory = guild.ReactionCategories?.FirstOrDefault(x => x.Id == message.Id);
var reactionCategoryItem = reactionCategory?.ReactionRoles.Single(x => x.Emoji == emoji.ToString());
var reactionMessageItem = guild.ReactionMessages?.Single(x => x.Id == message.Id)?.ReactionRoles.Single(x => x.Emoji == emoji.ToString());
var roleId = ulong.MinValue;
var categoryRoleId = ulong.MinValue;
if (reactionCategoryItem != null)
{
categoryRoleId = reactionCategory.RoleId;
roleId = reactionCategoryItem.RoleId;
}
if (reactionMessageItem != null)
{
roleId = reactionMessageItem.RoleId;
}
var role = channel.Guild.GetRole(roleId);
var categoryRole = channel.Guild.GetRole(categoryRoleId);
if (role != null)
{
if (member.Roles.Contains(role))
{
this.logger.Information($"The role '{role.Name}' was revoked from '{member.GetUsertag()}' on the guild '{channel.Guild.Name}' ({channel.GuildId}).");
await member.RevokeRoleAsync(role);
await member.SendMessageAsync($"The role {Formatter.InlineCode(role.Name)} has been revoked from you on {Formatter.Bold(channel.Guild.Name)}.");
}
else
{
this.logger.Information($"The role '{role.Name}' was granted to '{member.GetUsertag()}' on the guild '{channel.Guild.Name}' ({channel.GuildId}).");
await member.GrantRoleAsync(role);
await member.SendMessageAsync($"The role {Formatter.InlineCode(role.Name)} has been granted to you on {Formatter.Bold(channel.Guild.Name)}.");
}
await message.DeleteReactionAsync(emoji, member);
}
}
/// <summary>
/// listens for reactions from users and responds accordingly
/// </summary>
/// <returns></returns>
public async Task<GameState> RunLobby()
{
var timeOut = TimeSpan.FromSeconds(1);
while (CurrentGameStatus != GameState.Finished)
{
var emojiReaction = await _Interactivity.WaitForReactionAsync(x => x.Message == _EmbedMessage, timeOut);
if (!emojiReaction.TimedOut)
{
var emoji = emojiReaction.Result.Emoji;
var user = emojiReaction.Result.User;
if (_ValidReactEmojis.Contains(emoji))
{
if (emoji == _PlayGame)
{
await StartOrPauseGame(user);
}
else if (emoji == _StopGame)
{
await RestartGame(user);
}
else if (emoji == _LeaveLobby)
{
if (await LeaveLobby(user))
break;
}
else if (emoji != _LeaveLobby)
{
await OnEmbedMessageReaction(user, emoji);
}
}
else
{
//delete unwanted reactions
await _EmbedMessage.DeleteReactionsEmojiAsync(emoji);
}
//delete the latest reaction
await _EmbedMessage.DeleteReactionAsync(emoji, user);
}
}
return CurrentGameStatus.GetValueOrDefault();
}
public async void ManageRole(DiscordChannel channel, DiscordMessage message, DiscordUser user, DiscordEmoji emoji, BaseDiscordClient client)
{
var roleId = _listener[message.Id.ToString()][emoji];
var role = channel.Guild.GetRole(roleId);
var member = await channel.Guild.GetMemberAsync(user.Id);
if (member.Roles.Contains(role))
{
_logger.Information($"The role '{role.Name}' was revoked from '{user.Username}#{user.Discriminator}' on the guild '{channel.Guild.Name}' ({channel.Guild.Id}).");
await((DiscordMember)user).RevokeRoleAsync(role);
}
else
{
_logger.Information($"The role '{role.Name}' was granted to '{user.Username}#{user.Discriminator}' on the guild '{channel.Guild.Name}' ({channel.Guild.Id}).");
await((DiscordMember)user).GrantRoleAsync(role);
}
await message.DeleteReactionAsync(emoji, user);
}
private async Task OnMessageReactionAdded(DiscordClient dClient, MessageReactionAddEventArgs args)
{
if (args.Guild.Id != Guilds.Bloon || args.Channel.Id != BloonChannels.Settings || args.User.Id == dClient.CurrentUser.Id)
{
return;
}
DiscordChannel settingsChannel = await this.dClient.GetChannelAsync(BloonChannels.Settings);
DiscordChannel botMods = await this.dClient.GetChannelAsync(BloonChannels.BotMods);
DiscordMessage featureMessage = await settingsChannel.GetMessageAsync(args.Message.Id);
Feature feature = this.featureManager.Features.Where(f => f.Name == featureMessage.Embeds[0]?.Title).FirstOrDefault();
if (feature == null)
{
return;
}
else if (args.Emoji.Id == FeatureEmojis.ToggleOff && feature.Enabled)
{
await feature.Disable();
await this.featureManager.UpdateFeatureStatusAsync(feature.Name, false);
await botMods.SendMessageAsync($"{args.User.Username}#{args.User.Discriminator} *disabled* `{feature.Name}` at {DateTime.Now}\n" +
$"{featureMessage.JumpLink}");
}
else if (args.Emoji.Id == FeatureEmojis.ToggleOn && !feature.Enabled)
{
await feature.Enable();
await this.featureManager.UpdateFeatureStatusAsync(feature.Name, true);
await botMods.SendMessageAsync($"{args.User.Username}#{args.User.Discriminator} *enabled* `{feature.Name}` at {DateTime.Now}\n" +
$"{featureMessage.JumpLink}");
}
await featureMessage.ModifyAsync(embed : CreateFeatureEmbed(feature));
await featureMessage.DeleteReactionAsync(args.Emoji, args.User);
}
private static async Task BadUpdateAsync(DiscordClient client, DiscordUser user, DiscordMessage message, DiscordEmoji emoji)
{
if (message?.Channel.Id != Config.BotChannelId)
{
return;
}
if (!user.IsSmartlisted(client, message.Channel.Guild))
{
return;
}
await Moderation.ToggleBadUpdateAnnouncementAsync(message).ConfigureAwait(false);
try
{
await message.DeleteReactionAsync(emoji, user).ConfigureAwait(false);
}
catch { }
}
private static async Task SetReactions(DiscordMessage message, IEnumerable <Answer> answers, bool processOld = false, bool deleteOld = true)
{
var existingReactions = message.Reactions;
var answerEmojis = answers.Select(a => a.Emoji).ToArray();
bool reactionsOk = existingReactions.Count() == answers.Count() ?
existingReactions.Select(r => r.Emoji).Zip(answerEmojis).All(p => p.First.Id == p.Second.Id) : false;
if (reactionsOk)
{
//Clean others
foreach (var p in existingReactions.SelectMany(r => message.GetReactionsAsync(r.Emoji).Result.Select((u) => (User: u, Reaction: r))))
{
if (p.User.IsCurrent)
{
continue;
}
if (processOld && answerEmojis.Contains(p.Reaction.Emoji))
{
await answers.FirstOrDefault(a => a.Emoji == p.Reaction.Emoji).InvokeFromEmoji(p.User, message);
}
if (deleteOld)
{
await message.DeleteReactionAsync(p.Reaction.Emoji, p.User);
}
}
}
else
{
//Clear, replace
await message.DeleteAllReactionsAsync();
foreach (var emoji in answerEmojis)
{
await Task.Delay(100); //Will it suffice?
await message.CreateReactionAsync(emoji);
}
}
}
/// <summary>Deletes another user's reaction.</summary> public static Task DeleteReactionAsync(this DiscordMessage message, string emoji, DiscordUser user, string reason = null) => message.DeleteReactionAsync(emoji.ToEmoji(), user, reason);
public static async Task Reaction_Roles(DiscordClient Client, MessageReactionAddEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.Emoji.Id != 0 && !e.User.IsBot)
{
new Thread(async() =>
{
DiscordEmoji used = e.Emoji;
DiscordMessage sourcemsg = e.Message;
DiscordUser username = e.User;
List <DB.ReactionRoles> ReactionRoles = DB.DBLists.ReactionRoles;
var RoleInfo = (from rr in ReactionRoles
where rr.Server_ID == e.Channel.Guild.Id
where rr.Message_ID == sourcemsg.Id
where rr.Reaction_ID == used.Id
select rr).FirstOrDefault();
if (RoleInfo != null)
{
DiscordGuild guild = await Client.GetGuildAsync(Convert.ToUInt64(RoleInfo.Server_ID));
if (RoleInfo.Type == "acquire")
{
DiscordMember rolemember = username as DiscordMember;
if (rolemember.Roles.Any(w => w.Id == Convert.ToUInt64(RoleInfo.Role_ID)))
{
await rolemember.RevokeRoleAsync(guild.GetRole(Convert.ToUInt64(RoleInfo.Role_ID)));
}
else
{
await rolemember.GrantRoleAsync(guild.GetRole(Convert.ToUInt64(RoleInfo.Role_ID)));
}
Thread.Sleep(20000);
await sourcemsg.DeleteReactionAsync(used, e.User, null);
}
else if (RoleInfo.Type == "activate")
{
DiscordRole role = guild.GetRole(Convert.ToUInt64(RoleInfo.Role_ID));
string msg = $"---";
if (role.IsMentionable)
{
await role.ModifyAsync(mentionable: false);
msg = $"{role.Name} ⨯";
ActivateRolesTimer.RemoveAt(ActivateRolesTimer.FindIndex(a => a.Guild == e.Guild && a.Role == role));
}
else if (!role.IsMentionable)
{
await role.ModifyAsync(mentionable: true);
msg = $"{role.Name} ✓";
ActivateRolesTimer newItem = new()
{
Guild = guild,
Role = role,
Time = DateTime.Now
};
ActivateRolesTimer.Add(newItem);
}
await sourcemsg.DeleteReactionAsync(used, e.User, null);
DiscordMessage m = await e.Channel.SendMessageAsync(msg);
Thread.Sleep(3000);
await m.DeleteAsync();
}
}
}).Start();
await Task.Delay(0);
}
});
await Task.Delay(1);
}
private async Task ProcessRaidLobbyReactionDM(DiscordUser user, DiscordChannel channel, DiscordMessage message, DiscordEmoji emoji)
{
if (SupportersOnly)
{
var hasPrivilege = await _client.IsSupporterOrHigher(user.Id, _config);
if (!hasPrivilege)
{
await message.RespondAsync($"{user.Mention} does not have the supporter role assigned.");
return;
}
}
var origMessageId = Convert.ToUInt64(Utils.GetBetween(message.Content, "#", "#"));
var lobby = GetLobby(channel, ref origMessageId);
var settings = await GetRaidLobbySettings(lobby, origMessageId, message, channel);
if (settings == null)
{
_logger.Error($"Failed to find raid lobby settings for original raid message id {origMessageId}.");
return;
}
await message.DeleteReactionAsync(emoji, user);
var lobMessage = default(DiscordMessage);
var embedMsg = settings.RaidMessage?.Embeds[0];
switch (emoji.Name)
{
//case "1⃣":
// break;
//case "2⃣":
// break;
//case "3⃣":
// break;
//case "4⃣":
// break;
case "5⃣":
lobby.UsersComing[user.Id].Eta = RaidLobbyEta.Five;
lobby.UsersComing[user.Id].EtaStart = DateTime.Now;
lobMessage = await UpdateRaidLobbyMessage(lobby, settings.RaidLobbyChannel, embedMsg);
await message.DeleteAllReactionsAsync();
break;
case "🔟":
lobby.UsersComing[user.Id].Eta = RaidLobbyEta.Ten;
lobby.UsersComing[user.Id].EtaStart = DateTime.Now;
lobMessage = await UpdateRaidLobbyMessage(lobby, settings.RaidLobbyChannel, embedMsg);
await message.DeleteAllReactionsAsync();
break;
case "❌":
if (!lobby.UsersComing.ContainsKey(user.Id))
{
lobby.UsersComing.Remove(user.Id);
lobMessage = await UpdateRaidLobbyMessage(lobby, settings.RaidLobbyChannel, embedMsg);
}
break;
}
_config.RaidLobbies.ActiveLobbies[origMessageId] = lobby;
_config.Save();
}
public static async Task ReactionAdd(ModCoreShard bot, MessageReactionAddEventArgs e)
{
GuildSettings cfg = null;
using (var db = bot.Database.CreateContext())
{
cfg = e.Channel.Guild.GetGuildSettings(db);
if (cfg == null)
{
return;
}
if (cfg.ReactionRoles.Any(x => (ulong)x.ChannelId == e.Channel.Id && (ulong)x.MessageId == message.Id && (ulong)x.Reaction.EmojiId == e.Emoji.Id && x.Reaction.EmojiName == e.Emoji.Name))
{
var rrid = (ulong)cfg.ReactionRoles.First(
x => (ulong)x.ChannelId == e.Channel.Id && (ulong)x.MessageId == message.Id && (ulong)x.Reaction.EmojiId == e.Emoji.Id && x.Reaction.EmojiName == e.Emoji.Name).RoleId;
var rrrole = e.Channel.Guild.GetRole(rrid);
var mem = await e.Channel.Guild.GetMemberAsync(e.User.Id);
if (!mem.Roles.Any(x => x.Id == rrid))
{
await mem.GrantRoleAsync(rrrole);
}
}
var emoji = cfg.Starboard.Emoji;
DiscordEmoji em = null;
if (emoji.EmojiId != 0)
{
em = DiscordEmoji.FromGuildEmote(e.Client, (ulong)emoji.EmojiId);
}
else
{
em = DiscordEmoji.FromUnicode(e.Client, emoji.EmojiName);
}
if (!cfg.Starboard.AllowNSFW && e.Channel.IsNSFW)
{
return;
}
if (cfg.Starboard.Enable && e.Emoji == em)
{
long sbmid = 0;
var c = e.Channel.Guild.Channels.First(x => x.Key == (ulong)cfg.Starboard.ChannelId).Value;
if (c.Id == e.Channel.Id) // star on starboard entry
{
/*if (db.StarDatas.Any(x => (ulong)x.StarboardMessageId == message.Id))
* {
* var other = db.StarDatas.First(x => (ulong)x.StarboardMessageId == message.Id);
* var count = db.StarDatas.Count(x => (ulong)x.StarboardMessageId == message.Id);
* if (!db.StarDatas.Any(x => x.MessageId == other.MessageId && x.StargazerId == (long)e.User.Id))
* {
* var chn = await e.Client.GetChannelAsync((ulong)other.ChannelId);
* var msg = await chn.GetMessageAsync((ulong)other.MessageId);
*
* if (msg.Author.Id == e.User.Id || e.User.IsBot)
* return;
*
* var d = await (await c.GetMessageAsync((ulong)other.StarboardMessageId)).ModifyAsync($"{e.Emoji}: {count + 1} ({msg.Id}) in {msg.Channel.Mention}", embed: BuildMessageEmbed(msg));
* sbmid = (long)d.Id;
* await db.StarDatas.AddAsync(new DatabaseStarData
* {
* ChannelId = other.ChannelId,
* GuildId = (long)e.Channel.Guild.Id,
* MessageId = other.MessageId,
* AuthorId = other.AuthorId,
* StarboardMessageId = sbmid,
* StargazerId = (long)e.User.Id,
* });
* await db.SaveChangesAsync();
* }
* }*/
// Removing this behaviour for jump links.
}
else // star on actual message
{
message = await e.Channel.GetMessageAsync(e.Message.Id);
if (message.Author.Id == e.User.Id)
{
await message.DeleteReactionAsync(e.Emoji, message.Author);
return;
}
if (db.StarDatas.Any(x => (ulong)x.MessageId == message.Id))
{
var count = db.StarDatas.Count(x => (ulong)x.MessageId == message.Id);
if (db.StarDatas.Any(x => (ulong)x.MessageId == message.Id && x.StarboardMessageId != 0))
{
var other = db.StarDatas.First(x => (ulong)x.MessageId == message.Id && x.StarboardMessageId != 0);
var msg = await c.GetMessageAsync((ulong)other.StarboardMessageId);
var d = await msg.ModifyAsync($"{e.Emoji}: {count + 1} ({message.Id}) in {message.Channel.Mention}", embed : BuildMessageEmbed(message));
sbmid = (long)d.Id;
}
else
{
if (count + 1 >= cfg.Starboard.Minimum)
{
// create msg
var d = await c.ElevatedMessageAsync($"{e.Emoji}: {count + 1} ({message.Id}) in {message.Channel.Mention}", embed : BuildMessageEmbed(message));
sbmid = (long)d.Id;
}
}
}
else if (cfg.Starboard.Minimum <= 1)
{
var d = await c.ElevatedMessageAsync($"{e.Emoji}: 1 ({message.Id}) in {message.Channel.Mention}", embed : BuildMessageEmbed(message));
sbmid = (long)d.Id;
}
await db.StarDatas.AddAsync(new DatabaseStarData
{
ChannelId = (long)e.Channel.Id,
GuildId = (long)e.Channel.Guild.Id,
MessageId = (long)message.Id,
AuthorId = (long)message.Author.Id,
StarboardMessageId = sbmid,
StargazerId = (long)e.User.Id,
});
// somebody once told me...
var allstars = db.StarDatas.Where(x => (ulong)x.MessageId == message.Id).ToList();
allstars.ForEach(x => x.StarboardMessageId = sbmid);
db.StarDatas.UpdateRange(allstars);
await db.SaveChangesAsync();
}
}
}
}
public async void LyricEm(CommandContext ctx, DiscordMessage init, int select, dynamic myresponse, dynamic dresponse)
{
try
{
try { await init.DeleteReactionAsync(DiscordEmoji.FromName(ctx.Client, ":page_facing_up:"), ctx.Message.Author); }
catch { }
var interactivity = ctx.Client.GetInteractivity();
int lyse = 0;
string tumurl = "";
if (myresponse.items[select].pvs.Count != 0)
{
tumurl = myresponse.items[select].pvs[0].thumbUrl;
}
var emim = new DiscordEmbedBuilder
{
Color = new DiscordColor("#68D3D2"),
Title = "Results!"
};
emim.WithThumbnail(tumurl);
emim.AddField("Artist", myresponse.items[select].artistString, true);
emim.AddField("Title", myresponse.items[select].defaultName, true);
emim.WithFooter("Requested by " + ctx.Message.Author.Username, ctx.Message.Author.AvatarUrl);
if (myresponse.items[select].lyrics.Count > 1)
{
await init.DeleteAllReactionsAsync();
var embed2 = new DiscordEmbedBuilder
{
Color = new DiscordColor("#68D3D2"),
Title = "Lyrics Entries!",
Description = "Multiple entries were found, select one!"
};
int an = 0;
string[] nums = { ":one:", ":two:", ":three:", ":four:", ":five:", ":six:", ":seven:", ":eight:", ":nine:", ":keycap_ten:" };
var blank = DiscordEmoji.FromGuildEmote(ctx.Client, 435447550196318218);
foreach (var entries in myresponse.items[select].lyrics)
{
if (an == 10)
{
break;
}
embed2.AddField("React " + DiscordEmoji.FromName(ctx.Client, nums[an]), $"[{entries.translationType}] + {entries.cultureCode.ToUpper()} by {entries.source}");
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, nums[an]));
an++;
}
await init.ModifyAsync(null, embed : embed2.Build());
var one = DiscordEmoji.FromName(ctx.Client, ":one:");
var two = DiscordEmoji.FromName(ctx.Client, ":two:");
var three = DiscordEmoji.FromName(ctx.Client, ":three:");
var four = DiscordEmoji.FromName(ctx.Client, ":four:");
var five = DiscordEmoji.FromName(ctx.Client, ":five:");
var six = DiscordEmoji.FromName(ctx.Client, ":six:");
var seven = DiscordEmoji.FromName(ctx.Client, ":seven:");
var eight = DiscordEmoji.FromName(ctx.Client, ":eight:");
var nine = DiscordEmoji.FromName(ctx.Client, ":nine:");
var ten = DiscordEmoji.FromName(ctx.Client, ":keycap_ten:");
try
{
var reSelect = await interactivity.WaitForReactionAsync(xe => (xe.Emoji == one || xe.Emoji == two || xe.Emoji == three || xe.Emoji == four || xe.Emoji == five || xe.Emoji == six || xe.Emoji == seven || xe.Emoji == eight || xe.Emoji == nine || xe.Emoji == ten) && xe.Message == init, ctx.Message.Author, TimeSpan.FromSeconds(30));
if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":one:"))
{
lyse = 0;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":two:"))
{
lyse = 1;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":three:"))
{
lyse = 2;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":four:"))
{
lyse = 3;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":five:"))
{
lyse = 4;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":six:"))
{
lyse = 5;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":seven:"))
{
lyse = 6;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":eight:"))
{
lyse = 7;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":nine:"))
{
lyse = 8;
}
else if (reSelect.Result.Emoji == DiscordEmoji.FromName(ctx.Client, ":keycap_ten:"))
{
lyse = 9;
}
}
catch
{
return;
}
await init.DeleteAllReactionsAsync();
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":pushpin:"));
if (myresponse.items[select].lyrics.Count != 0)
{
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":page_facing_up:"));
}
if (myresponse.items[select].pvs.Count != 0)
{
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":movie_camera:"));
}
if (dresponse.Count != 0)
{
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":revolving_hearts:"));
}
await init.CreateReactionAsync(DiscordEmoji.FromName(ctx.Client, ":x:"));
}
if (myresponse.items[select].lyrics[lyse].translationType.Length != 0)
{
emim.AddField("Language", myresponse.items[select].lyrics[lyse].translationType, true);
}
if (myresponse.items[select].lyrics[lyse].source.Length != 0)
{
emim.AddField("Source", myresponse.items[select].lyrics[lyse].source, true);
}
if (myresponse.items[select].lyrics[lyse].translationType.Length != 0)
{
emim.AddField("Type", myresponse.items[select].lyrics[lyse].translationType, true);
}
if (myresponse.items[select].lyrics[lyse].url.Length != 0)
{
emim.AddField("Link", myresponse.items[select].lyrics[lyse].url, true);
}
else
{
emim.AddField("Link", $"https://vocadb.net/S/{myresponse.items[select].id}", true);
}
if (myresponse.items[select].lyrics[lyse].value.Length > 2000)
{
emim.WithDescription("Lyrics too long, look at the link uwu");
}
else
{
emim.WithDescription(myresponse.items[select].lyrics[lyse].value);
}
var end = emim.Build();
await init.ModifyAsync(null, embed : end);
}
catch
{
await ctx.RespondAsync("Error!");
}
}
public async Task RemoveCargoReactRoleAsync(CommandContext ctx, DiscordChannel canalReactRole = null, DiscordEmoji emoji = null)
{
await ctx.TriggerTypingAsync();
new Thread(async() =>
{
try
{
DiscordEmbedBuilder embed = new DiscordEmbedBuilder();
if (canalReactRole == null || emoji == null)
{
embed.WithColor(Program.Bot.Utilities.HelpCommandsColor())
.WithAuthor("Como executar este comando:", null, Values.infoLogo)
.AddField("PC/Mobile", $"{ctx.Prefix}rr cargo.del Canal[Id] Emoji")
.WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
.WithTimestamp(DateTime.Now);
await ctx.RespondAsync(embed: embed.Build());
return;
}
if (string.IsNullOrWhiteSpace(emoji.Url))
{
embed.WithAuthor("Emoji inválido!", null, Values.infoLogo)
.WithColor(Program.Bot.Utilities.RandomColorEmbed())
.WithDescription("Digite um emoji válido!")
.WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
.WithTimestamp(DateTime.Now);
await ctx.RespondAsync(embed: embed.Build());
return;
}
IMongoDatabase local = Program.Bot.LocalDB;
IMongoCollection <Jogos> jogos = local.GetCollection <Jogos>(Values.Mongo.jogos);
IMongoCollection <Reacts> reacts = local.GetCollection <Reacts>(Values.Mongo.reacts);
FilterDefinition <Jogos> filtroJogos = Builders <Jogos> .Filter.Eq(x => x.idDoEmoji, emoji.Id);
List <Jogos> resultadoJogos = await(await jogos.FindAsync(filtroJogos)).ToListAsync();
Jogos ultimoResultadoJogo = resultadoJogos.LastOrDefault();
List <Reacts> resultadoReacts = await(await reacts.FindAsync(Builders <Reacts> .Filter.Eq(x => x.categoria, ultimoResultadoJogo.nomeDaCategoria))).ToListAsync();
Reacts ultimoResultadoReact = resultadoReacts.LastOrDefault();
if (resultadoJogos.Count != 0 && resultadoReacts.Count != 0)
{
DiscordMessage mensagem = await canalReactRole.GetMessageAsync(ultimoResultadoReact.idDaMensagem);
DiscordEmbed embedMensagemReactRole = mensagem.Embeds.LastOrDefault();
DiscordEmbedBuilder builder = new DiscordEmbedBuilder(embedMensagemReactRole);
DiscordRole cargoJogoEmbed = ctx.Guild.GetRole(ultimoResultadoJogo.idDoCargo);
IReadOnlyList <DiscordUser> MembrosReacoes = await mensagem.GetReactionsAsync(emoji);
string linhaMensagemEmbed = $"{emoji.ToString()} - {cargoJogoEmbed.Name}";
if (embedMensagemReactRole.Description.Contains(linhaMensagemEmbed))
{
string descricaoEmbed = embedMensagemReactRole.Description;
List <string> lista = descricaoEmbed.Split('\n').ToList();
lista.RemoveAt(lista.FindIndex(linha => linha.Contains(linhaMensagemEmbed)));
StringBuilder strEmbedFinal = new StringBuilder();
foreach (string linha in lista)
{
strEmbedFinal.Append($"{linha}\n");
}
builder.WithDescription(strEmbedFinal.ToString());
builder.WithAuthor(embedMensagemReactRole.Author.Name, null, Values.logoUBGE);
builder.WithColor(embedMensagemReactRole.Color.Value);
await mensagem.ModifyAsync(embed: builder.Build());
}
await jogos.DeleteOneAsync(filtroJogos);
DiscordMessage msgAguarde = await ctx.RespondAsync($"Aguarde, estou removendo as reações dos membros que está no {canalReactRole.Mention}...");
int i = 0;
foreach (DiscordUser Membro in MembrosReacoes)
{
try
{
await Task.Delay(200);
await mensagem.DeleteReactionAsync(emoji, Membro);
}
catch (Exception)
{
++i;
}
}
await msgAguarde.DeleteAsync();
if (i != 0)
{
await ctx.RespondAsync($"Existem **{i}** reações que não foram removidas por que os membros saíram da {ctx.Guild.Name}, por favor, remova-as manualmente. :wink:");
}
embed.WithAuthor("Jogo removido!", null, Values.logoUBGE)
.WithColor(Program.Bot.Utilities.RandomColorEmbed())
.WithThumbnailUrl(emoji.Url)
.WithDescription($"O cargo: {cargoJogoEmbed.Mention} e a reação: {emoji.ToString()} foram removidos com sucesso!{(i != 0 ? $"\n\n{i} reações restantes para serem removidas manualmente." : string.Empty)}")
.WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
.WithTimestamp(DateTime.Now);
await ctx.RespondAsync(embed: embed.Build());
}
else if (resultadoReacts.Count == 0)
{
await ctx.RespondAsync($"{ctx.Member.Mention}, essa categoria não existe!");
}
else if (resultadoJogos.Count == 0)
{
await ctx.RespondAsync($"{ctx.Member.Mention}, esse jogo não existe!");
}
}
catch (ArgumentException)
{
await ctx.RespondAsync($"{ctx.Member.Mention}, este emoji não foi encontrado!");
}
catch (Exception exception)
{
await Program.Bot.Logger.Error(Log.TypeError.Commands, exception);
}
}).Start();
}
public async static Task OnPendingGameReaction(DiscordClient sender, DiscordMessage msg, DiscordEmoji emoji, DiscordUser user, bool added)
{
var kanContext = KandoraContext.Instance;
var msgId = msg.Id;
var userId = user.Id.ToString();
var game = kanContext.PendingGames[msgId];
bool result = false;
var okEmoji = DiscordEmoji.FromName(sender, Reactions.OK);
var noEmoji = DiscordEmoji.FromName(sender, Reactions.NO);
if (emoji.Id == okEmoji.Id)
{
result = game.TryChangeUserOk(userId, isAdd: added);
}
else if (emoji.Id == noEmoji.Id)
{
result = game.TryChangeUserNo(userId, isAdd: added);
}
if (!result && added)
{
await msg.DeleteReactionAsync(emoji, user);
}
if (game.IsCancelled)
{
await msg.ModifyAsync($"All players have voted {noEmoji}, this log won't be recorded");
kanContext.PendingGames.Remove(msgId);
}
if (game.IsValidated)
{
DbService.Begin("recordgame");
try
{
var serverId = msg.Channel.GuildId.ToString();
var users = UserDbService.GetUsers();
var servers = ServerDbService.GetServers(users);
var server = servers[serverId];
var leagueConfig = LeagueConfigDbService.GetLeagueConfig(server.LeagueConfigId);
if (game.Log == null)
{
ScoreDbService.RecordIRLGame(game.UserIds, game.Scores, server, leagueConfig);
}
else
{
ScoreDbService.RecordOnlineGame(game.Log, server);
}
kanContext.PendingGames.Remove(msgId);
await msg.RespondAsync($"All players have voted {okEmoji}, this log has been recorded!");
await msg.DeleteReactionsEmojiAsync(okEmoji);
await msg.DeleteReactionsEmojiAsync(noEmoji);
DbService.Commit("recordgame");
}
catch (Exception e)
{
DbService.Rollback("recordgame");
await msg.RespondAsync(e.Message);
}
}
}
