public static async Task Spectator_ReactionAdd(MessageReactionAddEventArgs e)
{
if (e.User.GetMember().Roles.Contains(Global.Roles[PublicRole.Spectator]))
{
await e.Message.DeleteReactionAsync(e.Emoji, e.User, $"Spectator {e.User.Username} can't vote");
}
}
public static async Task ReactionAdded(DiscordClient sender, MessageReactionAddEventArgs e)
{
if (!(e.Channel.Id.ToString().Equals(Fields.channel) && e.Message.Id.ToString().Equals(Fields.message)))
{
return;
}
await e.Message.DeleteReactionAsync(e.Emoji, e.User);
switch (e.Emoji.GetDiscordName())
{
case ":shield:":
await OpenReport(e);
break;
case ":globe_with_meridians:":
await OpenHelp(e);
break;
case ":question:":
await OpenQuestion(e);
break;
case ":lock:":
await OpenPart(e);
break;
}
}
private static async Task Discord_MessageReactionAdded(MessageReactionAddEventArgs e)
{
if (e.Channel == e.Channel.Guild.GetChannel(693561503496011856))
{
await Suggestions.HandleSuggestionReaction(e);
}
}
private static async Task ReactionAdded(DiscordClient sender, MessageReactionAddEventArgs e)
{
if (e.Channel.Name != "welcome")
{
return;
}
String roleName = e.Emoji.GetDiscordName() switch
{
":red_circle:" => "he/him",
":yellow_circle:" => "they/them",
":green_circle:" => "she/her",
_ => null
};
if (roleName == null)
{
return;
}
DiscordRole role = e.Guild.Roles.Values.FirstOrDefault(x => x.Name == roleName);
if (role == null)
{
return;
}
if (e.User is not DiscordMember member)
{
return;
}
await member.GrantRoleAsync(role);
}
}
public async Task CheckLoli(MessageReactionAddEventArgs e)
{
var name = e.Emoji.GetDiscordName();
if (name != Config.Emojis.Underage)
{
return;
}
var msg = await e.Client.Guilds.First(g => g.Key == e.Message.Channel.GuildId).Value.GetChannel(e.Message.ChannelId)
.GetMessageAsync(e.Message.Id);
if (msg.Embeds.Count != 1)
{
return;
}
bool isParceville = ulong.TryParse(msg.Embeds[0].Footer.Text, out ulong id);
if (!isParceville)
{
return;
}
DiscordContext context = new DiscordContext();
var post = await context.TumblrPosts.FindAsync(Convert.ToInt64(id));
post.IsLoli = 1;
await context.SaveChangesAsync();
await msg.DeleteAsync(":underage:");
}
private Task MessageReactionAdded(MessageReactionAddEventArgs e)
{
if (e.User.IsBot)
{
return(Task.CompletedTask);
}
var client = e.Client;
var guild = e.Guild;
var channel = e.Channel;
var message = e.Message;
var reactionUser = e.User;
var emoji = e.Emoji;
var emojiName = e.Emoji.Name == "??" ? "an unknown reaction" : $"the reaction '{e.Emoji.Name}' ({e.Emoji.Id})";
if (channel.IsPrivate)
{
_logger.Information($"{reactionUser.GetUsertag()} ({reactionUser.Id}) has added {emojiName} to the message '{e.Message.Id}' in the direct message.");
return(Task.CompletedTask);
}
_logger.Information($"'{reactionUser.GetUsertag()}' ({reactionUser.Id}) has added {emojiName} to the message '{message.Id}' in the channel '{channel.Name}' ({channel.Id}) on the guild '{guild.Name}' ({guild.Id}).");
if (!_reactionListener.IsListener(message.Id, emoji, client))
{
return(Task.CompletedTask);
}
_reactionListener.ManageRole(channel, message, reactionUser, emoji, client);
return(Task.CompletedTask);
}
private async Task DiscordClientOnMessageReactionAdded(DiscordClient client, MessageReactionAddEventArgs reactionEvent)
{
if (reactionEvent.User.IsBot)
{
return;
}
// We have to get message instead of reactionEvent.Message - sometimes message here is null, especially
// when the bot has been restarted.
var message = await reactionEvent.Channel.GetMessageAsync(reactionEvent.Message.Id);
if (!message.Content.StartsWith(PaginationIdentifier))
{
return;
}
var header = message.Content.Substring(0, message.Content.IndexOf("\n"));
var paginationData = _paginationManager.ParsePaginationHeader(header);
var orderByData = ParseOrderByHeader(header);
_paginationManager.UpdatePagination(paginationData, reactionEvent);
var onlineList = GetOnlineList(paginationData.CurrentPage, orderByData, reactionEvent.Channel.Guild);
await reactionEvent.Message.DeleteReactionAsync(reactionEvent.Emoji, reactionEvent.User);
await reactionEvent.Message.ModifyAsync(onlineList);
}
private async Task MessageReactionAdd(MessageReactionAddEventArgs args)
{
if (args.Channel.IsPrivate)
{
return;
}
using (var db = new LiteDatabase("Data.db"))
{
var rms = db.GetCollection <ReactionMessage>();
var rm = rms.FindOne(x =>
x.GuildId == args.Channel.Guild.Id &&
x.ChannelId == args.Channel.Id &&
x.MessageId == args.Message.Id);
if (rm is null)
{
return;
}
foreach (var e in rm.EmojiToRole)
{
var emoji = await e.GetEmoji();
if (emoji != args.Emoji)
{
continue;
}
var member = await args.Channel.Guild.GetMemberAsync(args.User.Id);
await member.GrantRoleAsync(args.Channel.Guild.GetRole(e.Role));
return;
}
}
}
static async Task DuelReactionsAdded(MessageReactionAddEventArgs e)
{
if (!e.User.IsBot)
{
try
{
Duel duel = duels.Find(d => e.Message.Id == d.duel.message1 || e.Message.Id == d.duel.message2);
if (duel != null)
{
if (e.User.Id != duel.duel.duelist1 && e.User.Id != duel.duel.duelist2 /* && (await e.Channel.Guild.GetMemberAsync(e.User.Id)).Roles.Any(r => r.Id == staffRole)*/ && (e.Emoji.Id == 604972398424621066u || e.Emoji.Id == 604973811154288660u))
{
var another = await e.Channel.Guild.GetEmojiAsync(e.Emoji.Id == 604972398424621066u? 604973811154288660u : 604972398424621066u);
if ((await e.Message.GetReactionsAsync(another)).Any(u => u.Id == e.User.Id))
{
await e.Message.DeleteReactionAsync(another, e.User);
}
}
else
{
await e.Message.DeleteReactionAsync(e.Emoji, e.User);
}
}
}
catch (Exception ex) { Program.ErrorMessage(ex.ToString()); }
}
}
private async Task ClientOnMessageReactionAddedAsync(DiscordClient client, MessageReactionAddEventArgs e)
{
if (e.User.IsBot || !await _paginationService.IsPaginationSetAsync(e.Message))
{
return;
}
var paginationData = await _paginationService.GetPaginationDataForMessageAsync(e.Message);
if (_allowedPaginationTypes.Contains(paginationData.ContentType))
{
var items = await _cacheService.GetAsync <List <CoreInfo> >(CacheContentType.Cores);
var editedMessage = e.Message;
if (await _paginationService.DoActionAsync(editedMessage, e.Emoji, items.Count))
{
var updatedPaginationData = await _paginationService.GetPaginationDataForMessageAsync(editedMessage);
var tableWithPagination = BuildTableWithPagination(items, updatedPaginationData.CurrentPage);
editedMessage = await editedMessage.ModifyAsync(tableWithPagination);
}
await _paginationService.DeleteReactionAsync(editedMessage, e.User, e.Emoji);
}
}
private async Task ReactionAdded(MessageReactionAddEventArgs e)
{
try
{
if (e.User != e.Client.CurrentUser && Program.pairs.Any(x => x.InputPair == e.Channel.Id))
{
Pair p = Program.pairs.Find(x => x.InputPair == e.Channel.Id);
if ((e.Channel.Guild.GetMemberAsync(e.User.Id).Result).Roles.Any(x => x.Permissions.HasPermission(Permissions.ManageRoles)) && e.User != e.Client.CurrentUser)
{
var msg = await e.Channel.GetMessageAsync(e.Message.Id);
Suggestion sg = new Suggestion(msg);
var RetChn = e.Channel.Guild.GetChannel(p.OutputPair);
if (sg.Image.HasValue)
{
await RetChn.SendFileAsync(sg.Image.Value, null, false, EmbedBase.SuggestionEmbed(sg));
await e.Message.DeleteAsync();
}
}
}
}
catch (Exception ex)
{
StringBuilder data = new StringBuilder();
Console.WriteLine($"[EX <{ex.Message}> @ Sug.cs : ReactionAdded] \n\t{ex}");
}
}
public async Task CheckReactionAddedAsync(MessageReactionAddEventArgs e)
{
if (e.User.Id == Application.Current.Discord.CurrentUser.Id)
{
// We don't want to respond to our own reactions.
return;
}
var roleCategory = Application.Current.Settings.ReactionRoles.FirstOrDefault(x => x.DiscordMessageId == e.Message.Id);
if (roleCategory == null)
{
return;
}
// It is a reaction message we sent; handle it.
// Grab required role:
var role = roleCategory.Roles.FirstOrDefault(x => x.Emoji == e.Emoji);
if (role == null)
{
// TODO: log
return;
}
await((DiscordMember)e.User).GrantRoleAsync(e.Guild.Roles.Values.First(x => x.Name == role.RoleName));
}
private async Task OnMessageReactionAdded(MessageReactionAddEventArgs e)
{
if (MessageReactionAdded != null)
{
await MessageReactionAdded(e);
}
}
private async Task DiscordReactionAdded(DiscordClient sender, MessageReactionAddEventArgs e)
{
await Task.Delay(0);
if (!e.User.IsCurrent && !e.User.IsBot)
{
if (MessageReactionListeners.TryGetValue(e.Guild.Id, out var guildMessageReactionListeners))
{
if (guildMessageReactionListeners.TryGetValue(e.Message.Id, out var reactionListeners))
{
foreach (var listener in reactionListeners)
{
try {
await listener.OnReactionAdd(e);
} catch (Exception exc) {
await SendException(this, new SendExceptionEventArgs {
Exception = exc,
Channel = e.Channel,
LogExceptionType = "GenericExceptionNotCaught"
});
}
}
}
}
}
}
public void UpdatePagination(PaginationData paginationData, MessageReactionAddEventArgs reactionEvent)
{
switch (reactionEvent.Emoji.GetDiscordName())
{
case LeftEmojiName:
{
if (paginationData.CurrentPage > 1)
{
paginationData.CurrentPage--;
}
break;
}
case RightEmojiName:
{
if (paginationData.CurrentPage < paginationData.PagesCount)
{
paginationData.CurrentPage++;
}
break;
}
}
}
internal static async Task ChallengeDuelReactionAdded(MessageReactionAddEventArgs e)
{
if (!e.User.IsBot)
{
ChallengeDuel cd = challengeDuels.Find(c => c.message.Id == e.Message.Id);
if (cd != null)
{
if (e.User.Id == cd.duelist2.Id && (e.Emoji.Id == 604972398424621066u || e.Emoji.Id == 604973811154288660u))
{
cd.Remove(null);
if (e.Emoji.Id == 604972398424621066u)
{
string subject = (await Subjects.RandomAsync())?.Replace('-', ' ');
if (subject != null)
{
Duel d = await AddAsync(cd.duelist1.Id, cd.duelist2.Id, 0, 0, false, subject);
await e.Channel.SendMessageAsync(string.Empty, false, Program.bot.GetEmbed("The duel has started!", $"The duel between <@{cd.duelist1.Id}> and <@{cd.duelist2.Id}> has started!", $"Subject: **{subject}**.", "Time: **24 hours**.", "When You finished your build, attach the image (**.png** or **.jpg**) of your work.", "Good luck!"));
}
else
{
await e.Channel.SendMessageAsync($"Subjects not found, <@{Program.config.StaffRole}>.");
}
}
}
else
{
await e.Message.DeleteReactionAsync(e.Emoji, e.User);
}
}
}
}
private Task _discordClient_MessageReactionAdded(DiscordClient sender, MessageReactionAddEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.Guild == null || e.Emoji == null || _textChannel == null || e.Channel.Id != _textChannel.Id ||
e.Emoji != _config.MentionRoleEmoji)
{
return;
}
// Check that the message reacted to is a role embed
if (_existingRoleEmbeds.ContainsValue(e.Message.Id))
{
if (e.User is DiscordMember member)
{
// Ignore actions from the bot
if (member.IsSelf(_discordClient))
{
return;
}
var(result, role) = await TryParseRoleFromEmbedAsync(e.Message);
if (result)
{
await member.GrantRoleAsync(role);
}
}
}
});
return(Task.CompletedTask);
}
async Task HandleReactionAdd(MessageReactionAddEventArgs eventargs)
{
await Task.Yield();
foreach (var req in _requests)
{
var emojis = await req.GetEmojisAsync();
var msg = await req.GetMessageAsync();
var usr = await req.GetUserAsync();
if (msg.Id == eventargs.Message.Id)
{
if (eventargs.User.Id == usr.Id)
{
await PaginateAsync(req, eventargs.Emoji);
}
else if (eventargs.User.Id != _client.CurrentUser.Id)
{
if (eventargs.Emoji != emojis.Left &&
eventargs.Emoji != emojis.SkipLeft &&
eventargs.Emoji != emojis.Right &&
eventargs.Emoji != emojis.SkipRight &&
eventargs.Emoji != emojis.Stop)
{
await msg.DeleteReactionAsync(eventargs.Emoji, eventargs.User);
}
}
}
}
}
private async Task ReactionAdded(MessageReactionAddEventArgs e)
{
if (e.Guild == null)
{
return;
}
if (e.User.IsBot)
{
return;
}
var categories = categoryCache.Query().Where(x => x.ChannelId == e.Channel.Id).ToList();
var category = categories.FirstOrDefault(x => x.MessageId == e.Message.Id);
if (!categories.Any() || category == null)
{
return;
}
if (!category.Data.ContainsKey(e.Emoji.Id))
{
await e.Message.DeleteReactionAsync(e.Emoji, e.User);
return;
}
var member = await e.Guild.GetMemberAsync(e.User.Id);
await member.GrantRoleAsync(e.Guild.GetRole(category.Data[e.Emoji.Id]));
}
async Task HandleReactionAdd(MessageReactionAddEventArgs eventargs)
{
await Task.Yield();
// foreach request add
foreach (var req in _requests)
{
if (req.message.Id == eventargs.Message.Id)
{
if (req._collected.Any(x => x.Emoji == eventargs.Emoji && x.Users.Any(y => y.Id == eventargs.User.Id)))
{
var reaction = req._collected.First(x => x.Emoji == eventargs.Emoji && x.Users.Any(y => y.Id == eventargs.User.Id));
req._collected.TryRemove(reaction);
reaction.Users.Add(eventargs.User);
req._collected.Add(reaction);
}
else
{
req._collected.Add(new Reaction()
{
Emoji = eventargs.Emoji,
Users = new ConcurrentHashSet <DiscordUser>()
{
eventargs.User
}
});
}
}
}
}
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");
}
}
}
}
// Client has assigned a role
internal static Task Role_Assigned(MessageReactionAddEventArgs e, DiscordMember member, DiscordRole role)
{
e.Client.DebugLogger.LogMessage(LogLevel.Debug, "Rolebot", $"User: {member} Role Assigned: {role}",
DateTime.Now);
return(Task.CompletedTask);
}
async Task HandleReactionAdd(MessageReactionAddEventArgs eventargs)
{
await Task.Yield();
foreach (var req in _requests)
{
// match message
if (req._message.Id == eventargs.Message.Id && req._message.ChannelId == eventargs.Channel.Id)
{
if (req._emojis.Contains(eventargs.Emoji) && !req._collected.Any(x => x.Voted.Contains(eventargs.User)))
{
if (eventargs.User.Id != _client.CurrentUser.Id)
{
req.AddReaction(eventargs.Emoji, eventargs.User);
}
}
else
{
var member = await eventargs.Channel.Guild.GetMemberAsync(eventargs.Client.CurrentUser.Id);
if (eventargs.Channel.PermissionsFor(member).HasPermission(Permissions.ManageMessages))
{
await eventargs.Message.DeleteReactionAsync(eventargs.Emoji, eventargs.User);
}
}
}
}
}
private Task HandleReactionAdd(DiscordClient client, MessageReactionAddEventArgs eventargs)
{
if (this._requests.Count == 0)
{
return(Task.CompletedTask);
}
_ = Task.Run(async() =>
{
foreach (var req in this._requests)
{
// match message
if (req._message.Id == eventargs.Message.Id && req._message.ChannelId == eventargs.Channel.Id)
{
if (req._emojis.Contains(eventargs.Emoji) && !req._collected.Any(x => x.Voted.Contains(eventargs.User)))
{
if (eventargs.User.Id != this._client.CurrentUser.Id)
{
req.AddReaction(eventargs.Emoji, eventargs.User);
}
}
else
{
var member = await eventargs.Channel.Guild.GetMemberAsync(client.CurrentUser.Id).ConfigureAwait(false);
if (eventargs.Channel.PermissionsFor(member).HasPermission(Permissions.ManageMessages))
{
await eventargs.Message.DeleteReactionAsync(eventargs.Emoji, eventargs.User).ConfigureAwait(false);
}
}
}
}
});
return(Task.CompletedTask);
}
private Task HandleReactionAdd(DiscordClient client, MessageReactionAddEventArgs eventargs)
{
// foreach request add
foreach (var req in this._requests)
{
if (req._message.Id == eventargs.Message.Id)
{
if (req._collected.Any(x => x.Emoji == eventargs.Emoji && x.Users.Any(y => y.Id == eventargs.User.Id)))
{
var reaction = req._collected.First(x => x.Emoji == eventargs.Emoji && x.Users.Any(y => y.Id == eventargs.User.Id));
req._collected.TryRemove(reaction);
reaction.Users.Add(eventargs.User);
req._collected.Add(reaction);
}
else
{
req._collected.Add(new Reaction()
{
Emoji = eventargs.Emoji,
Users = new ConcurrentHashSet <DiscordUser>()
{
eventargs.User
}
});
}
}
}
return(Task.CompletedTask);
}
public async Task <bool> AddReactionAsync(MessageReactionAddEventArgs e)
{
var reaction = new Reaction();
reaction.reaction = e.Emoji.Name;
reaction.user = e.User.Username;
reaction.time = DateTimeOffset.Now.ToUnixTimeMilliseconds();
var chat = utilityService.GetChat(e.Message, e.Message.MentionedUsers);
var conversationName = utilityService.GetConversationName(e.Message);
var metadata = utilityService.GetMetadata(e.Message);
var reactionRequest = new ReactionRequest {
reaction = reaction, chat = chat, type = configuration.ChatType, conversationName = conversationName, metadata = metadata
};
var httpContent = utilityService.GetHttpContent(reactionRequest);
var response = await client.PutAsync(configuration.ApiUrl + "/api/reactionupdate", httpContent);
response.EnsureSuccessStatusCode();
var jsonResponse = await response.Content.ReadAsStringAsync();
var success = JsonConvert.DeserializeObject <bool>(jsonResponse);
return(success);
}
public static async Task BuildVoteAddHandler(MessageReactionAddEventArgs e)
{
if (e.Channel.Name == "builds")
{
using (var db = new BuildContext())
{
var build = db.Builds.FirstOrDefault(b => b.MessageId == e.Message.Id);
if (build == null)
{
return;
}
if (e.Emoji == DiscordEmoji.FromName(Program.Client, ":arrow_up:"))
{
build.UpVotes++;
}
else if (e.Emoji == DiscordEmoji.FromName(Program.Client, ":arrow_down:"))
{
build.DownVotes++;
}
db.Update(build);
await db.SaveChangesAsync();
if (build.UpVotes + build.DownVotes - 2 >= 10 &&
(double)build.DownVotes / (double)(build.UpVotes + build.DownVotes - 2) >= 0.70)
{
await e.Message.DeleteAsync();
}
}
}
}
private async Task Client_MessageReactionAddedAsync(DiscordClient client, MessageReactionAddEventArgs e)
{
if (e.User.IsBot || !await _paginationService.IsPaginationSetAsync(e.Message))
{
return;
}
var paginationData = await _paginationService.GetPaginationDataForMessageAsync(e.Message);
if (_allowedPaginationTypes.Contains(paginationData.ContentType))
{
var items = await GetLaunchesAsync(paginationData.ContentType, paginationData.Parameter);
if (items != null)
{
var editedMessage = e.Message;
if (await _paginationService.DoActionAsync(editedMessage, e.Emoji, items.Count))
{
var updatedPaginationData = await _paginationService.GetPaginationDataForMessageAsync(editedMessage);
var launchesList = BuildTableWithPagination(items, updatedPaginationData.ContentType, updatedPaginationData.CurrentPage);
editedMessage = await editedMessage.ModifyAsync(launchesList);
}
await _paginationService.DeleteReactionAsync(editedMessage, e.User, e.Emoji);
}
}
}
public async Task HandleAddReactionAsync(DiscordClient client, MessageReactionAddEventArgs args)
{
if (args.Emoji.Id > 0L)
{
//It's a custom emoji
var emoji = $":{args.Emoji.Name}:";
try
{
var emojiObj = DiscordEmoji.FromName(client, emoji);
}
catch (ArgumentException)
{
_logger.LogInformation($"{args.Message.Author.Username} reacted with an emoji not present on this server: {emoji}. Ignoring...");
return;
}
_logger.LogInformation($"{args.User.Username} reacted {emoji}");
await _database.InsertEmojiAsync(new LogEmoji
{
EmojiId = emoji,
Username = args.User.Username,
MessageTimestamp = TimeZoneInfo.ConvertTimeFromUtc(args.Message.Timestamp.UtcDateTime, TZConvert.GetTimeZoneInfo("Romance Standard Time")),
IsReaction = true
});
}
}
public MessageReactionEventArgs(MessageReactionAddEventArgs e)
{
Message = e.Message;
Channel = e.Channel;
User = e.User;
Emoji = e.Emoji;
}
