public async Task NewMessageSetup(IMessageChannel channel, ulong messageId, string description = "") { if (_reactRoleService.IsPreparingMessage) { await ReplyAsync("A message is already being prepared, please finish."); } else { var linkedMessage = await channel.GetMessageAsync(messageId); if (linkedMessage == null) { await ReplyAsync($"Message ID \"{messageId}\" passed in does not exist"); return; } _reactRoleService.NewMessage = new UserReactMessage { ChannelId = channel.Id, Description = description, MessageId = messageId }; await ReplyAsync( $"Setup began, Reaction roles will be attached to {linkedMessage.GetJumpUrl()}"); await ReplyAsync( "Use `ReactRole Emote` \"Role\" \"Emoji\" \"Name (optional)\" to add emotes."); } }
private async Task QuoteMessage(IMessageChannel channel, ulong id) { var message = await channel.GetMessageAsync(id); var builder = new EmbedBuilder() .WithColor(new Color(200, 128, 128)) .WithTimestamp(message.Timestamp) .WithFooter(footer => { footer .WithText($"In channel {message.Channel.Name}"); }) .WithAuthor(author => { author .WithName(message.Author.Username) .WithIconUrl(message.Author.GetAvatarUrl()); }) .AddField("Original message", message.Content); var embed = builder.Build(); await ReplyAsync("", false, embed); await Task.Delay(1000); await Context.Message.DeleteAsync(); }
/// <summary> /// Clean up a channel /// </summary> /// <param name="channel">The channel to clean up</param> private async static void Clean(IMessageChannel channel) { // Remove all announcements that have expired from both the channel and the config (where necessary) var announcements = Config.Instance.ChannelConfigs.Where(x => x.ChannelId == channel.Id).Single().ChannelData.Announcements; List <ulong> toRemove = new List <ulong>(); foreach (var a in announcements) { var message = await channel.GetMessageAsync(a.Key); if (message == null) { toRemove.Add(a.Key); } else { if (a.Value < DateTime.Now) { List <IMessage> toDelete = new List <IMessage>(); toDelete.Add(message); await channel.DeleteMessagesAsync(toDelete); toRemove.Add(a.Key); } } } foreach (var remove in toRemove) { announcements.Remove(remove); } Config.Instance.Write(); }
private Task ReadyAsync() { //Console.WriteLine($"{_client.CurrentUser} is connected!"); bool msgFound = false; SocketGuild guild = _client.GetGuild(Convert.ToUInt64(_config.discordGuildID)); IMessageChannel channel = guild.GetChannel(Convert.ToUInt64(_config.discordChannelID)) as IMessageChannel; if (_config.discordMessageID != null) { Task <IMessage> msg = channel.GetMessageAsync(Convert.ToUInt64(_config.discordMessageID)); msg.Wait(); IUserMessage mesg = msg.Result as IUserMessage; if (mesg != null) { msgFound = true; mesg.ModifyAsync(x => x.Content = _message); } } if (_config.discordMessageID == null || !msgFound) { Task <IUserMessage> msg = channel.SendMessageAsync(_message); msg.Wait(); IUserMessage mesg = msg.Result; _config.setDiscordMessageNumber(Convert.ToString(mesg.Id)); _config.saveData(); } Environment.Exit(0); return(Task.CompletedTask); }
public async Task Edit(IMessageChannel channel, ulong messageId, [Remainder] string text) { if (string.IsNullOrWhiteSpace(text) || channel == null) { return; } var imsg = await channel.GetMessageAsync(messageId).ConfigureAwait(false); if (!(imsg is IUserMessage msg) || imsg.Author.Id != Context.Client.CurrentUser.Id) { return; } var rep = new ReplacementBuilder() .WithDefault(Context) .Build(); if (CREmbed.TryParse(text, out var crembed)) { rep.Replace(crembed); await msg.ModifyAsync(x => { x.Embed = crembed.ToEmbedBuilder().Build(); x.Content = crembed.PlainText?.SanitizeMentions() ?? ""; }).ConfigureAwait(false); } else { await msg.ModifyAsync(x => x.Content = text.SanitizeMentions()) .ConfigureAwait(false); } }
public static async Task DeleteMessage(ulong guildId, ulong channelId, ulong messageId) { IGuild guild = null; IMessageChannel channel = null; if (guildId != 0 && channelId != 0) { guild = Program.client.GetGuild(guildId); if (guild != null) { try { var messages = new List <IMessage>(); channel = (IMessageChannel)await guild.GetChannelAsync(channelId); messages.Add(await channel.GetMessageAsync(messageId)); await channel.DeleteMessagesAsync(messages); } catch (Exception ex) { channel = null; } } } }
/// <summary> /// Checks to see if there is an existing tsv file; /// and if so, checks if it is valid and the last saved message exists. /// (Note the possible thrown ValidationException). /// </summary> /// <returns>Null if does not exist. The IMessage of the last saved message if exists.</returns> /// <exception cref="ValidationException">Thrown upon invalid file (wrong header, message ID invalid, etc).</exception> private async Task <IMessage> CheckExisting() { string tsvPath = Path.Join(_path, WriterThread.TSV_FILE_NAME); if (!File.Exists(tsvPath)) { return(null); } using (StreamReader stream = new StreamReader(tsvPath)) using (CsvReader csv = new CsvReader(stream, WriterThread.CSV_CONFIG)) { string tsvChronPath = Path.Join(_path, TSV_CHRON); if (File.Exists(tsvChronPath)) { throw new FieldValidationException(csv.Context, $"{tsvChronPath} exists."); } csv.Read(); // advance to beginning of file CsvMessage csvMsg = csv.GetRecords <CsvMessage>().Last(); // expensive? IMessage msg = await _channel.GetMessageAsync(csvMsg.Id); if (msg == null) { throw new FieldValidationException(csv.Context, $"Discord message {csvMsg.Id} not found in channel."); } return(msg); } }
public static async Task SetOfflineStream(ulong guildId, string offlineMessage, ulong channelId, ulong messageId) { IGuild guild = null; IMessageChannel channel = null; if (guildId != 0 && channelId != 0) { guild = Program.client.GetGuild(guildId); if (guild != null) { try { channel = (IMessageChannel)await guild.GetChannelAsync(channelId); var message = (IUserMessage)await channel.GetMessageAsync(messageId); await message.ModifyAsync(m => m.Content += offlineMessage); } catch (Exception ex) { channel = null; } } } }
public async Task <bool> HandleMessageUpdatedAsync(IMessageChannel channel, IMessage updatedMessage, Lazy <Task <IMessage> > freshMessageFactory) { try { var newMessage = await freshMessageFactory.Value; var(success, _, commandArgs) = await VoteService.TryMatchVoteCommand(newMessage); if (success) { // newMessage has Reactions.Count == 0, always var freshMessage = await channel.GetMessageAsync(newMessage.Id); if (freshMessage is IUserMessage freshUserMessage) { await VoteService.ProcessVoteCommandAsync(freshUserMessage, commandArgs); } return(true); } else { await VoteService.DeleteAssociatedVoteReplyIfExistsAsync(channel, newMessage.Id); } } catch (Exception e) { Logger.LogError(e, "Could not process updated message {0} in channel {1}", updatedMessage.Id, channel); } return(false); }
public async Task Qu(ulong id, IMessageChannel ch = null) { #region Grab messages IMessage m; if (ch == null) { m = await Context.Channel.GetMessageAsync(id); } else { m = await ch.GetMessageAsync(id); } #endregion if (m == null) { await ReplyAsync("Sorry, I couldn't find the specified message."); return; } await Context.Message.DeleteAsync(); var eb = BuildQuote(m); if (eb == null) { await ReplyAsync("Sorry, this message cannot be quoted."); return; } await Context.Channel.SendMessageAsync(Context.User.Mention + " quoted the following message:", embed : eb.Build()); }
public static async Task <IMessage> GetMessageAsync(ulong uid, IMessageChannel chan) { IMessage msg; if (uid != 0) { msg = await chan.GetMessageAsync(uid); if (msg != null) { return(msg); } } if (chan is not ITextChannel textChan || uid == 0) { return(null); } foreach (ITextChannel c in await textChan.Guild.GetTextChannelsAsync()) { try { msg = await c.GetMessageAsync(uid); if (msg != null) { return(msg); } } catch (Discord.Net.HttpException) { } } return(null); }
public async Task PinMessage([Summary("The ID of the message to pin.")] string messageId, [Remainder, Summary("The ID of the channel the message is in.")] IMessageChannel channel) { List <ulong> allowedChannels = new List <ulong>() { 681270126657798295, 681273506964701222, 143149937247387649, 448202199852646431 }; if (Xml.CommandAllowed("pin", Context) && allowedChannels.Contains(channel.Id)) { if (channel == null) { channel = (ITextChannel)Context.Channel; } var msg = await channel.GetMessageAsync(Convert.ToUInt64(messageId)); try { var pinChannel = await Context.Guild.GetTextChannelAsync(JackFrostBot.UserSettings.Channels.PinsChannelId(Context.Guild.Id)); var embed = Embeds.Pin((IGuildChannel)Context.Channel, msg, Context.Message.Author); await pinChannel.SendMessageAsync("", embed : embed).ConfigureAwait(false); } catch { await Context.Channel.SendMessageAsync("Could not find referenced message in the specified channel."); } } }
public async Task Unsign(ulong userID, IMessageChannel channel) { var signups = _map.GetService <SignupsData>(); //var user = _client.GetUser(userID); if (signups.Missions.Any(x => x.SignupChannel == channel.Id)) { var mission = signups.Missions.Single(x => x.SignupChannel == channel.Id); Console.WriteLine($"[{DateTime.Now.ToString()}] {userID} removed from mission {channel.Name} by {Context.User.Username}"); await mission.Access.WaitAsync(-1); try { foreach (var team in mission.Teams) { var teamMsg = await channel.GetMessageAsync(team.TeamMsg) as IUserMessage; var embed = teamMsg.Embeds.Single(); if (team.Slots.Any(x => x.Signed.Contains(userID))) { team.Slots.Single(x => x.Signed.Contains(userID)).Signed.Remove(userID); mission.SignedUsers.Remove(userID); var newDescription = MiscHelper.BuildTeamSlots(team); var newEmbed = new EmbedBuilder { Title = embed.Title, Color = embed.Color }; if (newDescription.Count == 2) { newEmbed.WithDescription(newDescription[0] + newDescription[1]); } else if (newDescription.Count == 1) { newEmbed.WithDescription(newDescription[0]); } if (embed.Footer.HasValue) { newEmbed.WithFooter(embed.Footer.Value.Text); } await teamMsg.ModifyAsync(x => x.Embed = newEmbed.Build()); } } } finally { mission.Access.Release(); } } }
private async Task QuoteMessage(ulong id, string subtitle = null, IMessageChannel channel = null) { if (subtitle != null && (subtitle.Contains("@everyone") || subtitle.Contains("@here"))) { return; } //If the channel is null, use the message context's channel. channel = channel ?? Context.Channel; //Find the message that was requested and make a link. IMessage message = await channel.GetMessageAsync(id); string messageLink = "https://discordapp.com/channels/" + Context.Guild.Id + "/" + (channel == null ? Context.Channel.Id : channel.Id) + "/" + id; //Build an embed which contains the quote EmbedBuilder builder = new EmbedBuilder() { Color = new Color(200, 128, 128), Timestamp = message.Timestamp, Footer = new EmbedFooterBuilder() { Text = $"In channel {message.Channel.Name}" }, Title = new EmbedBuilder() { Title = "Linkback", Url = messageLink }.ToString(), Author = new EmbedAuthorBuilder() { Name = message.Author.Username, IconUrl = message.Author.GetAvatarUrl() } }; //Add the original message builder.AddField("Original Message:", message.Content.Truncate(1024)); //Add a subtitle if one was given string subtitleText = null; if (subtitle != null) { subtitleText = $"{Context.User.Username}: {subtitle}"; builder.AddField($"{Context.User.Username}: ", subtitle); } //Build, and send the embed in a message. Embed embed = builder.Build(); await ReplyAsync(subtitleText, false, embed); //Delete the requesters command await Context.Message.DeleteAsync(); }
public async Task QuoteMessage(ulong messageId, IMessageChannel channel = null) { // If channel is null use Context.Channel, else use the provided channel channel ??= Context.Channel; var message = await channel.GetMessageAsync(messageId); if (message == null) { await Context.Message.DeleteAfterSeconds(seconds : 1); await ReplyAsync("No message with that id found.").DeleteAfterSeconds(seconds: 4); return; } if (message.Author.IsBot) // Can't imagine we need to quote the bots { await Context.Message.DeleteAfterSeconds(seconds : 2); return; } var messageLink = "https://discordapp.com/channels/" + Context.Guild.Id + "/" + channel.Id + "/" + messageId; var msgContent = message.Content == string.Empty ? "" : message.Content.Truncate(1020); var msgAttachment = string.Empty; if (message.Attachments?.Count > 0) { msgAttachment = "\t📸"; } var builder = new EmbedBuilder() .WithColor(new Color(200, 128, 128)) .WithTimestamp(message.Timestamp) .WithFooter(footer => { footer .WithText($"Quoted by {Context.User.Username}#{Context.User.Discriminator} • From channel {message.Channel.Name}") .WithIconUrl(Context.User.GetAvatarUrl()); }) .WithAuthor(author => { author .WithName(message.Author.Username) .WithIconUrl(message.Author.GetAvatarUrl()); }); if (msgContent == string.Empty && msgAttachment != string.Empty) { msgContent = "📸"; } msgContent += $"\n\n***[Linkback]({messageLink})***"; builder.Description = msgContent; await ReplyAsync(embed : builder.Build()); await Context.Message.DeleteAfterSeconds(1.0); }
public async Task <IMessage> GetCloseMessage(ulong userId, IMessageChannel chan) { string closeMsg = await GetCloseMessageId(userId, chan); if (closeMsg == "0") { return(null); } return(await chan.GetMessageAsync(ulong.Parse(closeMsg))); }
Task HandleReactionAsync(IMessageChannel channel, SocketReaction reaction, ReactionEvent eventType) { if (reaction.UserId != _discord.CurrentUser.Id) { _ = Task.Run(async() => { // retrieve message if (!(await channel.GetMessageAsync(reaction.MessageId) is IUserMessage message)) { return; } // retrieve user if (!(await channel.GetUserAsync(reaction.UserId) is IUser user)) { return; } // create context var context = new ReactionContext { Client = _discord, Message = message, User = user, GuildSettings = _guildSettingsCache[message.Channel], Reaction = reaction, Event = eventType }; try { foreach (var handler in _reactionHandlers) { if (await handler.TryHandleAsync(context)) { HandledReactions.Increment(); break; } } } catch (Exception e) { await _errorReporter.ReportAsync(e, context, false); } finally { ReceivedReactions.Increment(); } }); } return(Task.CompletedTask); }
public async Task EditAnnouncement(string title = null, string message = null, [Remainder, Summary("Optional message id to edit")] ulong id = 0) { await Log.LogMessage(Context); if (await Permissions.IsWarlord(Context) == false) { throw new UnauthorizedAccessException(); } if (title == null) { await ReplyAsync("Please provide a title"); return; } if (message == null) { await ReplyAsync("Please provide a message"); return; } IMessageChannel channel = await Channel.GetChannel(Context, "announcements"); IUserMessage umessage = null; if (id == 0) { IEnumerable <IMessage> messages = await channel.GetMessagesAsync(1).Flatten(); foreach (IMessage msg in messages) { umessage = (IUserMessage)await channel.GetMessageAsync(msg.Id); break; } } else { umessage = (IUserMessage)await channel.GetMessageAsync(id); } if (umessage != null) { await umessage.ModifyAsync(x => x.Content = Message.FormatAnnouncementMessage(Context, title, message)); await ReplyAsync("Announcement modified, please verify the result"); return; } }
private async Task ReadyAsync() { foreach (IGuild guild in Client.Guilds) { await OnLogAsync(LogSeverity.Info, Name, $"Joined {guild.Name} ({guild.Id})"); } if (restartChannel != null && restartMessage != null) { ulong restartMessageId = restartMessage.Id; ulong restartChannelId = restartChannel.Id; // Attempt to get the channel the bot was restarted from. restartChannel = Client.GetChannel(restartChannelId) as IMessageChannel; if (restartChannel is null) { restartChannel = await Client.GetDMChannelAsync(restartChannelId) as IMessageChannel; } // Attempt to get the confirmation message. if (restartChannel != null) { restartMessage = await restartChannel.GetMessageAsync(restartMessageId) as IUserMessage; } else { restartMessage = null; } if (restartMessage != null) { // Modify the confirmation message. await restartMessage.ModifyAsync(async m => { m.Embed = EmbedUtilities.BuildSuccessEmbed($"Restarting {Name.ToBold()}... and we're back!").ToDiscordEmbed(); await Task.CompletedTask; }); } } restartChannel = null; restartMessage = null; }
/// <summary> /// Sends a file to this message channel with an optional caption, then adds it to the command cache. /// </summary> /// <param name="channel">The source channel.</param> /// <param name="cache">The command cache that the messages should be added to.</param> /// <param name="commandId">The ID of the command message.</param> /// <param name="stream">The <see cref="Stream" /> of the file to be sent.</param> /// <param name="filename">The name of the attachment.</param> /// <param name="text">The message to be sent.</param> /// <param name="isTTS">Whether the message should be read aloud by Discord or not.</param> /// <param name="embed">The <see cref="EmbedType.Rich"/> <see cref="Embed"/> to be sent.</param> /// <param name="options">The options to be used when sending the request.</param> /// <param name="isSpoiler">Whether the message attachment should be hidden as a spoiler.</param> /// <param name="allowedMentions"> /// Specifies if notifications are sent for mentioned users and roles in the message <paramref name="text"/>. If <c>null</c>, all mentioned roles and users will be notified. /// </param> /// <returns>A task that represents an asynchronous send operation for delivering the message. The task result contains the sent message.</returns> public static async Task <IUserMessage> SendCachedFileAsync(this IMessageChannel channel, CommandCacheService cache, ulong commandId, Stream stream, string filename, string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null, bool isSpoiler = false, AllowedMentions allowedMentions = null) { IUserMessage response; bool found = cache.TryGetValue(commandId, out ulong responseId); if (found && (response = (IUserMessage)await channel.GetMessageAsync(responseId)) != null) { await response.DeleteAsync(); } response = await channel.SendFileAsync(stream, filename, text, isTTS, embed, options, isSpoiler, allowedMentions); cache.Add(commandId, response.Id); return(response); }
private async Task QuoteMessage(ulong id, string subtitle = null, IMessageChannel channel = null) { // If channel is null use Context.Channel, else use the provided channel channel = channel ?? Context.Channel; var message = await channel.GetMessageAsync(id); string messageLink = "https://discordapp.com/channels/" + Context.Guild.Id + "/" + (channel == null ? Context.Channel.Id : channel.Id) + "/" + id; var builder = new EmbedBuilder() .WithColor(new Color(200, 128, 128)) .WithTimestamp(message.Timestamp) .WithFooter(footer => { footer .WithText($"In channel {message.Channel.Name}"); }) .WithTitle("Linkback") .WithUrl(messageLink) .WithAuthor(author => { author .WithName(message.Author.Username) .WithIconUrl(message.Author.GetAvatarUrl()); }) .AddField("Original message", message.Content.Truncate(1020)); if (subtitle != null) { builder.AddField($"{Context.User.Username}: ", subtitle); } var embed = builder.Build(); await ReplyAsync((subtitle == null)? "" : $"*{Context.User.Username}:* {subtitle}", false, embed); await Task.Delay(1000); await Context.Message.DeleteAsync(); }
async Task ClosePoll(IMessageChannel channel, ulong messageId, params string[] additionalNotes) { string additionalNote = String.Join(' ', additionalNotes); var message = (IUserMessage)await channel.GetMessageAsync(messageId); var reactions = message.Reactions; string reactionCount = ""; foreach (var reaction in reactions) { reactionCount += $" {reaction.Key.Name} ({reaction.Value.ReactionCount})"; } await message.ModifyAsync((properties) => { properties.Content = message.Content + $"\n\nThe poll has been closed. Here's the vote results :{reactionCount}\nAdditional notes : {additionalNote}"; }); }
public static async Task <IMessage> GetMessage(string id, IMessageChannel chan) { ulong uid; if (!ulong.TryParse(id, out uid)) { return(null); } IMessage msg; if (uid != 0) { msg = await chan.GetMessageAsync(uid); if (msg != null) { return(msg); } } ITextChannel textChan = chan as ITextChannel; if (textChan == null || uid == 0) { return(null); } foreach (ITextChannel c in await textChan.Guild.GetTextChannelsAsync()) { try { msg = await c.GetMessageAsync(uid); if (msg != null) { return(msg); } } catch (Discord.Net.HttpException) { } } return(null); }
protected async Task <bool> InitMessage(IMessageChannel channel, ulong msgId, string[] footer, bool checkLen = true) { try { _msg = await channel.GetMessageAsync(msgId) as RestUserMessage; } catch { await ReplyAsync(database["string", "errParseMsgId"]); } if (_msg == null) { await ReplyAsync(database["string", "errMsgNotFound"]); return(false); } if (_msg.Embeds.Count != 1) { await ReplyAsync(database["string", "errMsgNotValid"]); return(false); } _oldEmbed = _msg.Embeds.ElementAt(0); //don't run this on delete or move if (_oldEmbed.Fields.Length >= 20 && checkLen) { await ReplyAsync(database["string", "errTooManyFields"]); return(false); } if (!footer.Contains(_oldEmbed.Footer.Value.ToString())) { await ReplyAsync(database["string", "errMsgNotValid"]); } return(true); }
/// <summary> /// Int 0 is to modify the message, int 1 is to send a new message /// </summary> public static async Task NotificationControlAsync(ulong messageid, ulong channelid, string msg, int status, int num = 0) { try { if (num == 0) { IMessageChannel channel = (IMessageChannel)KKK.Client.GetChannel(channelid); IUserMessage themessage = (IUserMessage)await channel.GetMessageAsync(messageid); await themessage.ModifyAsync(msgProperty => { msgProperty.Embed = Embed(msg, status); }); } else if (num == 1) { IMessageChannel channel = (IMessageChannel)KKK.Client.GetChannel(channelid); await channel.SendMessageAsync(null, false, Embed(msg, status)); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
/// <summary> /// Tries to delete a message. /// </summary> /// <param name="channel">The source channel.</param> /// <param name="message">The message.</param> public static async Task <bool> TryDeleteMessageAsync(this IMessageChannel channel, IMessage message) { message = await channel.GetMessageAsync(message.Id); return(await message.TryDeleteAsync()); }
private async Task DisplayAdventure(Adventure adventure) { try { // Get the channel for this adventure.. IMessageChannel channel = DiscordSocketClient.GetChannel(adventure.Channel) as IMessageChannel; // Get all players associated with this adventure. IEnumerable <Player> players = await PlayersRepository.GetAdventuringPlayersAsEnumerable(adventure.Id); // Get the adventureMessage that we will update. IUserMessage adventureMessage; // If we were passed the "RegenerateMessages" flag set to true, or if there is no Adventure Message, then create a new adventureMessage. if (adventure.RegenerateMessage || adventure.AdventureMessage == 0) { adventureMessage = await channel.SendMessageAsync("<ADVENTURE MESSAGE>") as IUserMessage; } // If we were passed the "RegenerateMessages" flag set to false, then retrieve the existing adventureMessage. else { adventureMessage = await channel.GetMessageAsync(adventure.AdventureMessage) as IUserMessage; } // Alter the messages to now have new status updates. EmbedBuilder embedBuilder = new EmbedBuilder(); embedBuilder.Color = Color.Blue; TimeSpan timePassed = DateTime.UtcNow - adventure.StartTime; string adventureHeader = $"ADVENTURE - {timePassed.ToString(@"mm\:ss")}"; embedBuilder.Title = adventureHeader; List <string> frontlinePlayers = new List <string>(); List <string> midlinePlayers = new List <string>(); List <string> backlinePlayers = new List <string>(); foreach (Player player in players) { double healthTicksRaw = player.Health / (double)player.MaxHealth; int healthTicks = 0; for (int i = 1; i < BarDisplaySize + 1; i++) { if (healthTicksRaw < (i / (double)BarDisplaySize)) { break; } healthTicks += 1; } string healthBar = "["; for (int i = 0; i < healthTicks; i++) { healthBar += "+"; } for (int i = 0; i < BarDisplaySize - healthTicks; i++) { healthBar += "-"; } healthBar += "]"; double manaTicksRaw = player.Mana / (double)Player.MaxMana; int manaTicks = 0; for (int i = 1; i < BarDisplaySize + 1; i++) { if (manaTicksRaw < (i / (double)BarDisplaySize)) { break; } manaTicks += 1; } string manaBar = "["; for (int i = 0; i < manaTicks; i++) { manaBar += "+"; } for (int i = 0; i < BarDisplaySize - manaTicks; i++) { manaBar += "-"; } manaBar += "]"; string display = $"<@{player.Id}> ({player.Class}) \n HP {player.Health}/{player.MaxHealth} {healthBar} \n MP {player.Mana}/{Player.MaxMana} {manaBar}"; switch (player.AdventureRank) { case Adventure.Rank.Frontline: frontlinePlayers.Add(display); break; case Adventure.Rank.Midline: midlinePlayers.Add(display); break; case Adventure.Rank.Backline: backlinePlayers.Add(display); break; default: throw new Exception("Invalid Rank!"); } } string frontlinePlayerField = string.Join("\n\n", frontlinePlayers.ToArray()); if (string.IsNullOrEmpty(frontlinePlayerField)) { frontlinePlayerField = "<No Players>"; } string midlinePlayerField = string.Join("\n\n", midlinePlayers.ToArray()); if (string.IsNullOrEmpty(midlinePlayerField)) { midlinePlayerField = "<No Players>"; } string backlinePlayerField = string.Join("\n\n", backlinePlayers.ToArray()); if (string.IsNullOrEmpty(backlinePlayerField)) { backlinePlayerField = "<No Players>"; } embedBuilder.AddField("Player Frontline", frontlinePlayerField); embedBuilder.AddField("Player Midline", midlinePlayerField); embedBuilder.AddField("Player Backline", backlinePlayerField); embedBuilder.AddField("\u200b", "\u200b"); string adventureLog = string.Join("\n", (adventure.Logs ?? new List <string>()).ToArray()); if (string.IsNullOrEmpty(adventureLog)) { adventureLog = "<No Logs>"; } embedBuilder.AddField("Adventure Log", adventureLog); await adventureMessage.ModifyAsync(m => { m.Content = ""; m.Embed = embedBuilder.Build(); }); // If we were passed the "RegenerateMessages" flag set to true, or if there was no AdventureMessage, then delete old adventureMessage if possible. // Then, toggle the "RegenerateMessages" flag to false, and set the new adventureMessage on the Adventure. if (adventure.RegenerateMessage || adventure.AdventureMessage == 0) { if (adventure.AdventureMessage != 0) { await channel.DeleteMessageAsync(await channel.GetMessageAsync(adventure.AdventureMessage)); } await AdventuresRepository.SetNewChannelsForMessages ( adventureId : adventure.Id, adventureMessage : adventureMessage.Id ); } } catch (Exception e) { Console.WriteLine(e); } }
public async void Launch(IMessageChannel channel, SocketGuild guild) { if (cts != null && !cts.IsCancellationRequested) { return; } await channel.SendMessageAsync("Служба оповещения включена"); cts = new CancellationTokenSource(); var regex = new Regex("\\d\\d.-..."); groups = guild.Roles .Where(it => regex.IsMatch(it.Name)); var sch = (await repository.GetAllSchedules())?.Filter(groups: this.groups.Select(it => it.Name)); lock (key) { this.schedule = sch; } if (schedule == null) { return; } ScheduleUpdater(); var msgFromId = 0UL; var msgToId = 0UL; var limit = 0; while (true) { var currentTime = GetMoscowDateTime(DateTime.Now); Console.WriteLine("Сервис оповещения о расписании: " + currentTime.ToString()); var shiftedTime = currentTime.AddMinutes(10); // Get lesson 10 min before start var currentOrder = Lesson.GetOrder(shiftedTime, false); var currentOrderEvening = Lesson.GetOrder(shiftedTime, true); var realIsStarted = Lesson.GetTime(currentOrder.Order, currentOrder.Evening).Item1 >= currentTime.TimeOfDay; var realIsStartedEvening = Lesson.GetTime( currentOrderEvening.Order, currentOrderEvening.Evening ).Item1 >= currentTime.TimeOfDay; var filteredLessons = schedule.GetSchedule(shiftedTime); filteredLessons = filteredLessons.Where(it => !it.GroupIsEvening && currentOrder.Started && realIsStarted && it.Order == currentOrder.Order || it.GroupIsEvening && currentOrderEvening.Started && realIsStartedEvening && it.Order == currentOrderEvening.Order ).ToList(); if (msgFromId != 0UL && msgToId != 0UL) { var flag = false; var collections = channel.GetMessagesAsync( msgToId, Direction.Before, limit: limit ); await foreach (var col in collections) { foreach (var message in col) { if (message.Author.IsBot) { await message.DeleteAsync(); await Task.Delay(700); } if (message.Id == msgFromId) { flag = true; break; } } if (flag) { break; } } await(await channel.GetMessageAsync(msgToId)).DeleteAsync(); } else if (msgFromId != 0UL) { await(await channel.GetMessageAsync(msgFromId)).DeleteAsync(); } limit = 0; if (filteredLessons.Count != 0) { msgFromId = (await channel.SendMessageAsync("Занятия через 10 минут")).Id; limit = filteredLessons.Count * 2 + 1; foreach (var lesson in filteredLessons) { var mentions = string.Join(", ", lesson.Groups .Select(it => { var q = groups.FirstOrDefault(role => role.Name.Equals(it.Title) ); return(q?.Mention ?? string.Empty); } ) ); await channel.SendMessageAsync(mentions); msgToId = (await ScheduleMessageUtils.SendLesson(channel, lesson, DateTime.Now)).Id; await Task.Delay(700); } } else { msgFromId = (await channel.SendMessageAsync("Через 10 минут занятий нет")).Id; msgToId = 0UL; Console.WriteLine($"Сейчас {currentOrder.Order + 1}-й занятие или " + $"{currentOrderEvening.Order + 1}-й занятие"); } var timeToSleep = GetTimeToSleep(currentOrder, currentOrderEvening); Console.WriteLine("Следующее оповещение через " + timeToSleep.ToString()); try { await Task.Delay(timeToSleep, cts.Token); } catch (TaskCanceledException e) { Console.WriteLine("Сервис оповещения о расписании остановлен: " + DateTime.Now.ToString()); await channel.SendMessageAsync("Служба оповещения остановлена"); return; } } }
public async Task ReactionAddedMethod(Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel channel, SocketReaction reaction) { //Test Values //ulong corporation = 326378973934256129; ulong corporation = 82021499682164736; IMessageChannel finalchannel = client.GetGuild(corporation).GetChannel(channel.Id) as IMessageChannel; IUserMessage message = await finalchannel.GetMessageAsync(cache.Id) as IUserMessage; if (reaction.Emote.Name.Contains("Drama") || reaction.Emote.Name.Contains("drama")) { try { archive.InsertDrama(message); await message.AddReactionAsync(new Emoji("\uD83D\uDC6E")); } catch (Exception ex) { await finalchannel.SendMessageAsync(ex.Message); } } else if (reaction.Emote.Name.Contains("1INF")) { IGuildUser reactionuser = client.GetGuild(corporation).GetUser(reaction.UserId); IGuildUser messageuser = client.GetGuild(corporation).GetUser(message.Author.Id); string user1 = ""; string user2 = ""; if (messageuser.Nickname != null) { user1 = messageuser.Nickname; } else { user1 = messageuser.Username; } if (reactionuser.Nickname != null) { user2 = reactionuser.Nickname; } else { user2 = reactionuser.Username; } SendHttpRequest request = new SendHttpRequest(); await reactionuser.SendMessageAsync(request.SendInfluence(user2, user1, 1, "INFLUENCE")); } else if (reaction.Emote.Name.Contains("5INF")) { IGuildUser reactionuser = client.GetGuild(corporation).GetUser(reaction.UserId); IGuildUser messageuser = client.GetGuild(corporation).GetUser(message.Author.Id); string user1 = ""; string user2 = ""; if (messageuser.Nickname != null) { user1 = messageuser.Nickname; } else { user1 = messageuser.Username; } if (reactionuser.Nickname != null) { user2 = reactionuser.Nickname; } else { user2 = reactionuser.Username; } SendHttpRequest request = new SendHttpRequest(); await reactionuser.SendMessageAsync(request.SendInfluence(user2, user1, 5, "INFLUENCE")); } else if (reaction.Emote.Name.Contains("10INF")) { IGuildUser reactionuser = client.GetGuild(corporation).GetUser(reaction.UserId); IGuildUser messageuser = client.GetGuild(corporation).GetUser(message.Author.Id); string user1 = ""; string user2 = ""; if (messageuser.Nickname != null) { user1 = messageuser.Nickname; } else { user1 = messageuser.Username; } if (reactionuser.Nickname != null) { user2 = reactionuser.Nickname; } else { user2 = reactionuser.Username; } SendHttpRequest request = new SendHttpRequest(); await reactionuser.SendMessageAsync(request.SendInfluence(user2, user1, 10, "INFLUENCE")); } }
/// <summary> /// Start a channel master for a specific channel in discord /// </summary> /// <param name="channelconfig">The representation of a channel in discord</param> /// <param name="channel">If you already have an instance of the channel master, you can pass it as a parameter</param> /// <returns>A bool depicting if the channel handler could be started</returns> public async static Task <bool> StartChannelMaster(ChannelConfig channelconfig, IMessageChannel channel = null) { // Try to get the channel object from the channel id in the config if (channel == null) { channel = Client.GetChannel(channelconfig.ChannelId) as IMessageChannel; } else { channelconfig = Config.Instance.ChannelConfigs.Where(x => x.ChannelId == channel.Id).Single(); } // Create a handler for each type of message the channel should be able to process var handlers = new List <IMessageHandler> { new WelcomeHandler(channelconfig), new AttendanceHandler(channelconfig), new BorderHandler(channelconfig), new ScheduleHandler(channelconfig), new AnnouncementHandler(channelconfig) }; // If the client couldn't get the channel, return false if (channel == null) { Config.Instance.DeleteConfig(channelconfig); } // Get all the messages that have been posted to the channel, remove any that have been deleted Dictionary <CommandType, IUserMessage> postedMessages = new Dictionary <CommandType, IUserMessage>(); if (channelconfig.ChannelData.PostedMessages == null) { channelconfig.ChannelData.PostedMessages = new Dictionary <CommandType, ulong>(); } // Check if a message has been deleted List <CommandType> toRemove = new List <CommandType>(); foreach (var m in channelconfig.ChannelData.PostedMessages) { IUserMessage userMessage = null; try { userMessage = await channel.GetMessageAsync(m.Value) as IUserMessage; } catch (Exception) { } if (userMessage == null) { toRemove.Add(m.Key); } else { postedMessages.Add(m.Key, userMessage); } } foreach (var type in toRemove) { channelconfig.ChannelData.PostedMessages.Remove(type); } Config.Instance.Write(); // If a handler doesn't have a message posted in the channel, post it's default message foreach (var h in handlers) { try { if (postedMessages.Where(x => x.Key == h.MessageType).Count() == 0) { IUserMessage userMessage = await channel.SendMessageAsync(h.DefaultMessage()); postedMessages.Add(h.MessageType, userMessage); channelconfig.ChannelData.PostedMessages.Add(h.MessageType, userMessage.Id); } } catch (Exception) { } } Config.Instance.Write(); // Start a channel handler ChannelMaster master = new ChannelMaster(Client.CurrentUser.Id, channel, handlers, postedMessages); ChannelMasters.Add(master); await Task.Run(() => master.Run()); return(true); }