/// <summary> /// Replies to a command context. /// </summary> /// <param name="ctx"></param> /// <param name="content"></param> /// <param name="embed"></param> /// <returns></returns> public async Task <DiscordMessage> ReplyAsync(CommandContext ctx, string content = null, DiscordEmbed embed = null) { //Prepare the response DiscordMessage response = null; //This is a command, so lets make sure we have a response var reply = await GetReplyFromMessageAsync(ctx.Message); if (reply != null && reply.CommandMsg == ctx.Message.Id) { //We are a reaction. We cannot create a new reaction, but we will remove our old one if (reply.ResponseType == Reply.SnowflakeType.Reaction) { await ctx.Message.DeleteOwnReactionAsync(DiscordEmoji.FromName(ctx.Client, reply.ResponseEmote)); } //We are just a message, so we will edit it if (reply.ResponseType == Reply.SnowflakeType.Message) { //Get the response message and load it into our memory cache // then modify the contents of the message var msg = await ctx.Channel.GetMessageAsync(reply.ResponseMsg); if (msg != null) { response = await msg.ModifyAsync(content, embed); } } //Remove ourself from the cache, not longer required. //_memcache.Remove(ctx.Message.Id); } //We do not have a response, so just create a new one if (response == null) { response = await ctx.RespondAsync(content : content, embed : embed); } //Store the reply await StoreReplyAsync(ctx, response); return(response); }
/// <summary> /// Creates a new instance of a help message. /// </summary> /// <param name="content">Contents of the message.</param> /// <param name="embed">Embed to attach to the message.</param> public CommandHelpMessage(string content = null, DiscordEmbed embed = null) { this.Content = content; this.Embed = embed; }
public static async Task <DiscordMessage> SendDirectMessage(this DiscordClient client, DiscordUser user, DiscordEmbed embed) { if (embed == null) { return(null); } return(await client.SendDirectMessage(user, string.Empty, embed)); }
public static Task <DiscordMessage> ElevatedMessageAsync(this DiscordMember m, DiscordEmbed embed) => m.SendMessageAsync(embed: embed);
/// <summary> /// DM this user. /// </summary> /// <param name="message">The string message to send.</param> /// <param name="embed">An optional embed to send.</param> /// <returns></returns> public async Task SendDMAsync(string message = null, DiscordEmbed embed = null) { DiscordChannel dm = await Member.CreateDmChannelAsync(); await dm.SendMessageAsync(message, false, embed); }
private async Task SendWelcomeMessage(DiscordMember member, DiscordEmbed embed) { var channel = await member.CreateDmChannelAsync(); await channel.SendMessageAsync(embed : embed); }
public static Task <DiscordMessage> ElevatedRespondAsync(this CommandContext ctx, DiscordEmbed embed) => ctx.RespondAsync(embed: embed);
public static async Task <DiscordMessage> SendAsync(DiscordChannel channel, string textContent, DiscordEmbed embedContent = null) { try { if (!ChannelHasPermission(channel, Permissions.SendMessages)) { return(null); } if (embedContent == null) { return(await channel.SendMessageAsync(textContent, false)); } else { // Either make sure we have permission to use embeds or convert the embed to text if (ChannelHasPermission(channel, Permissions.EmbedLinks)) { return(await channel.SendMessageAsync(textContent, false, embedContent)); } else { return(await channel.SendMessageAsync(MessageBuilder.EmbedToText(textContent, embedContent))); } } } catch (Newtonsoft.Json.JsonReaderException e) { Logger.Debug(e.ToString()); return(null); } catch (Exception e) { Logger.Error("Error occurred while attempting to send Discord message. Error message: " + e); return(null); } }
public static async Task <DiscordMessage> ModifyAsync(DiscordMessage message, string textContent, DiscordEmbed embedContent = null) { try { if (!ChannelHasPermission(message.Channel, Permissions.ManageMessages)) { return(null); } if (embedContent == null) { return(await message.ModifyAsync(textContent)); } else { // Either make sure we have permission to use embeds or convert the embed to text if (ChannelHasPermission(message.Channel, Permissions.EmbedLinks)) { return(await message.ModifyAsync(textContent, embedContent)); } else { await message.ModifyEmbedSuppressionAsync(true); // Remove existing embeds return(await message.ModifyAsync(MessageBuilder.EmbedToText(textContent, embedContent))); } } } catch (DSharpPlus.Exceptions.ServerErrorException e) { Logger.Debug(e.ToString()); return(null); } catch (Newtonsoft.Json.JsonReaderException e) { Logger.Debug(e.ToString()); return(null); } catch (DSharpPlus.Exceptions.NotFoundException e) { Logger.Debug(e.ToString()); return(null); } catch (Exception e) { Logger.Error("Error occurred while attempting to modify Discord message. Error message: " + e); return(null); } }
/// <summary> /// Sends a message through the webhook /// </summary> /// <param name="webhookId">ID of the webhook</param> /// <param name="webhookToken">The webhook's token</param> /// <param name="content">The message to send</param> /// <param name="embed">Embed to include in the message</param> /// <param name="profile">Custom Username and Avatar url (both are optional)</param> public static void SendWebhookMessage(this DiscordClient client, ulong webhookId, string webhookToken, string content, DiscordEmbed embed = null, DiscordWebhookProfile profile = null) { var properties = new WebhookMessageProperties() { Content = content, Embed = embed }; if (profile != null) { if (profile.NameProperty.Set) { properties.Username = profile.Username; } if (profile.AvatarProperty.Set) { properties.AvatarUrl = profile.AvatarUrl; } } client.HttpClient.Post($"/webhooks/{webhookId}/{webhookToken}", properties); }
private List <DiscordEmbedBuilder> GeneratePageText(List <string> cards, string rarity, DiscordEmbed parentEmbed) { List <DiscordEmbedBuilder> embeds = new List <DiscordEmbedBuilder>(); for (int i = 0; i < cards.Count; i += 13) { DiscordEmbedBuilder embed = new DiscordEmbedBuilder(parentEmbed); embed.AddField($"{rarity}", string.Join("\n", cards.GetRange(i, Math.Min(13, cards.Count - i))), false); embeds.Add(embed); } return(embeds); }
/// <summary> /// Quickly respond with a file to the message that triggered the command. /// </summary> /// <param name="fileName">Name of the file to send.</param> /// <param name="fileData">Stream containing the data to attach as a file.</param> /// <param name="content">Message to respond with.</param> /// <param name="isTTS">Whether the message is to be spoken aloud.</param> /// <param name="embed">Embed to attach to the message.</param> /// <returns>Message that was sent.</returns> public Task <DiscordMessage> RespondWithFileAsync(string fileName, Stream fileData, string content = null, bool isTTS = false, DiscordEmbed embed = null) => this.Message.RespondWithFileAsync(fileData, fileName, content, isTTS, embed);
/// <summary> /// Quickly respond to the message that triggered the command. /// </summary> /// <param name="content">Message to respond with.</param> /// <param name="isTTS">Whether the message is to be spoken aloud.</param> /// <param name="embed">Embed to attach.</param> /// <returns></returns> public Task <DiscordMessage> RespondAsync(string content = null, bool isTTS = false, DiscordEmbed embed = null) => this.Message.RespondAsync(content, isTTS, embed);
public EmbedViewer(DiscordMessage m, DiscordEmbed embed) { Embed = embed; InitializeComponent(); }
/// <summary> /// Quickly respond with multiple files to the message that triggered the command. /// </summary> /// <param name="content">Message to respond with.</param> /// <param name="files">Files to send.</param> /// <param name="is_tts">Whether the message is to be spoken aloud.</param> /// <param name="embed">Embed to attach to the message.</param> /// <returns>Message that was sent.</returns> public Task <DiscordMessage> RespondWithFilesAsync(Dictionary <string, Stream> files, string content = null, bool is_tts = false, DiscordEmbed embed = null) => this.Message.RespondWithFilesAsync(files, content, is_tts, embed);
public async static Task PardonWarns() { WarnRepository repo = new WarnRepository(ReadConfig.Config.ConnectionString); UserRepository urepo = new UserRepository(ReadConfig.Config.ConnectionString); bool result = repo.GetAll(out List <Warn> list); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync("Error getting all warns in TimerTick."); return; } int pardoned = 0; foreach (var item in list) { if ((item.Level > 0 && item.Level < 6 && item.Time <= DateTime.Now - TimeSpan.FromDays(14) || item.Level > 5 && item.Level < 11 && item.Time <= DateTime.Now - TimeSpan.FromDays(56)) && !item.Persistent) { pardoned++; result = repo.Delete(item.ID); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync($"Error deleting warn {item.ID} from {item.Time}, level {item.Level}."); } result = repo.GetAllByUser(item.User, out List <Warn> others); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync("Error reading other warns from the database."); } int counter = 0; foreach (var warn in others) { counter++; warn.Number = counter; result = repo.Update(warn); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync("Error updating the database."); break; } } result = urepo.Read(item.User, out User entity); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync("Error reading a user from the database"); continue; } result = urepo.Read(item.Mod, out User modEntity); if (!result) { _ = DiscordObjectService.Instance.ErrorLogChannel.SendMessageAsync("Error reading a user from the database"); continue; } try { DiscordMember member = await DiscordObjectService.Instance.Lathland.GetMemberAsync(entity.DcID); DiscordMember moderator = await DiscordObjectService.Instance.Lathland.GetMemberAsync(modEntity.DcID); DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder { Color = DiscordColor.Green, Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail { Url = member.AvatarUrl }, Title = $"Pardoned warn number {item.Number} of {member.DisplayName}#{member.Discriminator} ({member.Id})", Description = $"Warn from {item.Time}.", Footer = new DiscordEmbedBuilder.EmbedFooter { IconUrl = moderator.AvatarUrl, Text = moderator.DisplayName } }; DiscordEmbed embed = embedBuilder.Build(); _ = DiscordObjectService.Instance.WarnsChannel.SendMessageAsync(embed); } catch { DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder { Color = DiscordColor.Green, Title = $"Pardoned warn of {entity.DcID}", Description = $"Warn from {item.Time}.", Footer = new DiscordEmbedBuilder.EmbedFooter { Text = modEntity.DcID.ToString() } }; DiscordEmbed embed = embedBuilder.Build(); _ = DiscordObjectService.Instance.WarnsChannel.SendMessageAsync(embed); } } } if (pardoned >= 0) { _ = DiscordObjectService.Instance.TimerChannel.SendMessageAsync($"Timer ticked, {pardoned} warns pardoned."); } else { _ = DiscordObjectService.Instance.TimerChannel.SendMessageAsync("Timer ticked, no warns pardoned."); } }
public Task <DiscordMessage> RespondAsync(string message = "", bool tts = false, DiscordEmbed embed = default) { return(Context.RespondAsync(message, tts, embed)); }
public static async Task DM(CommandContext ctx, DiscordMember member, DiscordEmbed message) => await member.SendMessageAsync(embed : message);
public static async Task <IDiscordMessage> SendToUser(this DiscordEmbed embed, IDiscordUser user) { await Task.Yield(); return(await(await user.GetDMChannel()).SendMessageAsync("", false, embed)); }
public override async Task OperateCommand(CommandContext ctx, params string[] args) { await base.OperateCommand(ctx, args); string subCommand = args[0]; guildData data = Utils.returnGuildData(ctx.Guild.Id); switch (subCommand.ToLower()) { case "play": //Play the tunes! await VoiceJoin(ctx); //We need to download the spotify song or whatever if (args[1] != null) { //Start to play the song if (args[1].Contains("youtube") || args[1].Contains("youtu.be")) { } else if (args[1].Contains("spotify")) { //Initialise the spotify bot if has not done yet! if (api == null) { CredentialsAuth auth = new CredentialsAuth("7c09a36e2ef84c2abc068c8979103d17", "d21bc05a3f604089b176e3b3e5975e0b"); Token token = await auth.GetToken(); api = new SpotifyWebAPI { AccessToken = token.AccessToken, TokenType = token.TokenType }; } string uriCode = null; Uri uri = new UriBuilder(args[1]).Uri; if (args[1] != null) { //Get the spotify track from url or the uri code uriCode = uri.Segments[2]; } if (uriCode != null) { if (uri.Segments[1] == "track") { FullTrack track = await api.GetTrackAsync(uriCode); if (track.Artists != null) { List <string> artists = new List <string>(); foreach (SimpleArtist artist in track.Artists) { artists.Add(artist.Name); } string connectArtist = string.Join(",", artists.ToArray()); await ctx.RespondAsync("Playing: " + track.Name + " By: " + connectArtist); } if (track.HasError()) { await ctx.RespondAsync("The track when playing had an issue!"); } } else if (uri.Segments[1] == "playlist") { //Playlist FullPlaylist list = await api.GetPlaylistAsync(uriCode); await ctx.RespondAsync("Playing: " + list.Name); if (list.HasError()) { await ctx.RespondAsync("The playlist had and issue"); } } } else { await ctx.RespondAsync("Invalid url or uri code"); } } } else { await ctx.RespondAsync("No song link was defined!"); } break; case "stop": //Stop the tunes! break; case "leave": case "fuckoff": //Leave the channel forcefully! await VoiceLeave(ctx); break; case "autoleave": //Set if the bot should automatically leave the voice channel when no one is in the voice channel if (data.autoSongLeave == false) { data.autoSongLeave = true; await ctx.RespondAsync("This bot will leave the party when everyone else has finished!"); } else if (data.autoSongLeave == true) { data.autoSongLeave = false; await ctx.RespondAsync("This bot will keep on partying!"); } break; case "loop": //loop the song that is currently playing if (data.loopSong == false) { data.loopSong = true; await ctx.RespondAsync("Looping Song !"); } else if (data.loopSong == true) { data.loopSong = false; await ctx.RespondAsync("Not Looping Song!"); } break; default: case "help": //Show the help on it. Dictionary <string, string> argumentsHelp = new System.Collections.Generic.Dictionary <string, string>(); argumentsHelp.Add(";;song play", "specify a song right after play with a space then this bot will play or specify a link (overrides queue)"); argumentsHelp.Add(";;song stop", "stop whatever is playing"); argumentsHelp.Add(";;song leave", "forces the bot to leave the current voice channel"); argumentsHelp.Add(";;song autoleave", "turns on auto leave the bot will leave the channel when no one is present"); argumentsHelp.Add(";;song loop", "loops the current song and disables queue"); DiscordEmbed embedHelp = JosephineEmbedBuilder.CreateEmbedMessage(ctx, "Sub-Commands", "for ';;announce set'", null, JosephineBot.defaultColor, argumentsHelp, false); await ctx.RespondAsync("Go to http://discord.rickasheye.xyz/ for all sub-commands", false, embedHelp); break; } }
public static Task <DiscordMessage> ElevatedMessageAsync(this DiscordChannel channel, string s, DiscordEmbed embed) => channel.SendMessageAsync(s, embed: embed);
public async Task OsuProfile(InteractionContext ctx, [Option("nickname", "Никнейм юзера")] string nickname, [Choice("Bancho server", "bancho")] [Choice("Gatari server", "gatari")] [Option("server", "Возможные параметры: bancho, gatari")] string args) { if (!(ctx.Channel.Name.Contains("-bot") || ctx.Channel.Name.Contains("dev-announce"))) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent("Использование данной команды запрещено в этом текстовом канале. Используйте специально отведенный канал для ботов, связанных с osu!.") .AsEphemeral(true)); return; } if (string.IsNullOrEmpty(nickname)) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent("Вы ввели пустой никнейм..") .AsEphemeral(true)); return; } if (args.Contains("gatari")) { GUser guser = null; if (!gapi.TryGetUser(nickname, ref guser)) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent($"Не удалось получить информацию о пользователе `{nickname}`.") .AsEphemeral(true));; return; } List <GScore> gscores = gapi.GetUserBestScores(guser.id, 5); if (gscores is null || gscores.Count == 0) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent($"Не удалось получить информацию о лучших скорах пользователя `{nickname}`.") .AsEphemeral(true)); return; } GStatistics gstats = gapi.GetUserStats(guser.username); if (gstats is null) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent($"Не удалось получить статистику пользователя `{nickname}`.") .AsEphemeral(true)); return; } DiscordEmbed gembed = utils.UserToEmbed(guser, gstats, gscores); await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AddEmbed(gembed)); return; } if (args.Contains("bancho")) { User user = null; if (!api.TryGetUser(nickname, ref user)) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent($"Не удалось получить информацию о пользователе `{nickname}`.") .AsEphemeral(true)); return; } List <Score> scores = api.GetUserBestScores(user.id, 5); if (scores is null || scores.Count == 0) { await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent($"Не удалось получить информацию о лучших скорах пользователя `{nickname}`.") .AsEphemeral(true)); return; } DiscordEmbed embed = utils.UserToEmbed(user, scores); await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AddEmbed(embed)); } await ctx.CreateResponseAsync(DSharpPlus.InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().WithContent("Введенный сервер не поддерживается или не существует.") .AsEphemeral(true)); }
// Ignore timestamps private static bool IdenticalEmbed(DiscordEmbed a, DiscordEmbed b) { return(a.Title == b.Title && a.Description == b.Description && a.Color == b.Color); }
public Page(string content = "", DiscordEmbedBuilder embed = null) { this.Content = content; this.Embed = embed?.Build(); }
[Description("Manage the announcer everytime someone joins")] // this will be displayed to tell users what this command does when they invoke help public override async Task OperateCommand(CommandContext ctx, params string[] args) // this command takes no arguments { await base.OperateCommand(ctx); string argumentType = args[0]; guildData specificGuild = Utils.returnGuildData(ctx.Guild.Id); List <DiscordEmoji> emojis = new List <DiscordEmoji>(); emojis.Add(DiscordEmoji.FromName(ctx.Client, ":100:")); emojis.Add(DiscordEmoji.FromName(ctx.Client, ":ok_hand:")); List <DiscordEmoji> emojisFiltered = Utils.GetRandomPoggersEmoji(emojis); Random rnd = new Random(); var emoji = emojisFiltered[rnd.Next(emojisFiltered.Count)]; switch (argumentType.ToLower()) { case "demo": //Bring up a version of the put command await ctx.RespondAsync("Here are the demo embed messages"); string announcerMessage = specificGuild.AnnounceFormatDesc; string finalannouncerMessage = announcerMessage.Replace("{guildname}", ctx.Guild.Name); string announceTitle = specificGuild.AnnounceFormatBot; string finalAnnouncerTitle = announceTitle.Replace("{bot}", ctx.Client.CurrentUser.Username); DiscordEmbed embedMessageUser = JosephineEmbedBuilder.CreateEmbedMessage(ctx, finalAnnouncerTitle, finalannouncerMessage); await ctx.RespondAsync("", false, embedMessageUser); string announceTitleUser = specificGuild.AnnounceFormatUser; string finalAnnouncerTitleUser = announceTitleUser.Replace("{user}", ctx.Member.Username); DiscordEmbed embedMessageBot = JosephineEmbedBuilder.CreateEmbedMessage(ctx, finalAnnouncerTitleUser, finalannouncerMessage); await ctx.RespondAsync("", false, embedMessageBot); break; case "set": switch (args[1].ToLower()) { case "user": //Set the user join message if (args[2] != null || !args[2].Contains(string.Empty)) { //string afterwardsMessage = string.Join() specificGuild.AnnounceFormatUser = string.Join(" ", args).Substring(args[1].Length + args[2].Length); await ctx.RespondAsync("Changed the announcer message for the user. TO see what it looks like try ';;announce demo'"); } else { await ctx.RespondAsync("No message was defined!"); } break; case "bot": if (args[2] != null || !args[2].Contains(string.Empty)) { specificGuild.AnnounceFormatBot = string.Join(" ", args).Substring(args[1].Length + args[2].Length); await ctx.RespondAsync("Changed the announcer message for the bot. To see what it looks like try ';;announce demo'"); } else { await ctx.RespondAsync("No message was defined!"); } break; case "description": if (args[2] != null || !args[2].Contains(string.Empty)) { specificGuild.AnnounceFormatDesc = string.Join(" ", args).Substring(args[1].Length + args[2].Length); await ctx.RespondAsync("Changed the description message for the bot. To see what it looks like try ';;announce demo'"); } else { await ctx.RespondAsync("No message was defined!"); } break; default: case "help": if (!args[1].ToLower().Contains("help")) { await ctx.RespondAsync("Unable to change as there is either an incorrect command argument(s) or no arguments at all!"); } Dictionary <string, string> arguments = new System.Collections.Generic.Dictionary <string, string>(); arguments.Add(";;announce set user <message>", "sets the user greeting (use {user} to be replaced with thier username)"); arguments.Add(";;announce set bot <message>", "sets the bot greeting (use {bot} to be replaced with the bot username)"); arguments.Add(";;announce set description <message>", "sets the greeting for both messages (use {guildname} to be replaced with the guild name)"); DiscordEmbed embed = JosephineEmbedBuilder.CreateEmbedMessage(ctx, "Sub-Commands", "for ';;announce set'", null, JosephineBot.defaultColor, arguments); await ctx.RespondAsync("Go to http://discord.rickasheye.xyz/ for all sub-commands", false, embed); break; } break; case "off": if (specificGuild.announceJoin == false) { await ctx.RespondAsync("Announcer is already off run the on sub-command"); } else { specificGuild.announceJoin = false; await ctx.Message.CreateReactionAsync(emoji); } break; case "on": if (specificGuild.announceJoin == true) { await ctx.RespondAsync("Announcer is already on run the off sub-command"); } else { specificGuild.announceJoin = true; await ctx.Message.CreateReactionAsync(emoji); } break; default: case "help": Dictionary <string, string> argumentsHelp = new System.Collections.Generic.Dictionary <string, string>(); argumentsHelp.Add(";;announce demo", "shows the greeting messages for the user and the bots on this server"); argumentsHelp.Add(";;announce set", "utility to set the greeting messages on this server"); argumentsHelp.Add(";;announce off", "turns the announcer off"); argumentsHelp.Add(";;announce on", "turns the announcer on"); DiscordEmbed embedHelp = JosephineEmbedBuilder.CreateEmbedMessage(ctx, "Sub-Commands", "for ';;announce set'", null, JosephineBot.defaultColor, argumentsHelp); await ctx.RespondAsync("Go to http://discord.rickasheye.xyz/ for all sub-commands", false, embedHelp); break; } }
/// <summary> /// Quickly respond with a file to the message that triggered the command. /// </summary> /// <param name="file_data">Stream containing the data to attach as a file.</param> /// <param name="content">Message to respond with.</param> /// <param name="is_tts">Whether the message is to be spoken aloud.</param> /// <param name="embed">Embed to attach to the message.</param> /// <returns>Message that was sent.</returns> public Task <DiscordMessage> RespondWithFileAsync(FileStream file_data, string content = null, bool is_tts = false, DiscordEmbed embed = null) => this.Message.RespondWithFileAsync(file_data, content, is_tts, embed);
/// <summary> /// Sends a message through the webhook /// </summary> /// <param name="content">The message to send</param> /// <param name="embed">Embed to include in the message</param> /// <param name="profile">Custom Username and Avatar url (both are optional)</param> public void SendMessage(string content, DiscordEmbed embed = null, DiscordWebhookProfile profile = null) { Client.SendWebhookMessage(Id, Token, content, embed, profile); }
/// <summary> /// Quickly respond with a file to the message that triggered the command. /// </summary> /// <param name="file_path">Path to the file to be attached to the message.</param> /// <param name="content">Message to respond with.</param> /// <param name="is_tts">Whether the message is to be spoken aloud.</param> /// <param name="embed">Embed to attach to the message.</param> /// <returns>Message that was sent.</returns> public Task <DiscordMessage> RespondWithFileAsync(string file_path, string content = null, bool is_tts = false, DiscordEmbed embed = null) { return(this.Message.RespondWithFileAsync(file_path, content, is_tts, embed)); }
public static async Task <DiscordMessage> SendDirectMessage(this DiscordClient client, DiscordUser user, string message, DiscordEmbed embed) { try { var dm = await client.CreateDmAsync(user); if (dm != null) { var msg = await dm.SendMessageAsync(message, false, embed); return(msg); } } catch (Exception) { //_logger.Error(ex); _logger.Error($"Failed to send DM to user {user.Username}."); } return(null); }
public static EmbedJson ReverseEmbed(DiscordMessage message) { if (message == null) { return(null); } DiscordEmbed embed = message.Embeds.ElementAt(0); Thumbnail thumbnail = null; Image image = null; Author author = null; Footer footer = null; if (embed.Thumbnail != null) { thumbnail = new Thumbnail() { Url = embed.Thumbnail.Url.ToString() } } ; if (embed.Image != null) { image = new Image() { Url = embed.Image.Url.ToString() } } ; if (embed.Author != null) { author = new Author() { Url = embed.Author.Url.ToString(), IconUrl = embed.Author.IconUrl.ToString(), Name = embed.Author.Name } } ; if (embed.Footer != null) { footer = new Footer() { IconUrl = embed.Footer.IconUrl?.ToString() ?? null, Text = embed.Footer.Text } } ; List <Field> fields = null; if (embed.Fields != null) { fields = new List <Field>(); foreach (DiscordEmbedField f in embed.Fields) { fields.Add(new Field() { Inline = f.Inline, Value = f.Value, Name = f.Name }); } } EmbedJson result = new EmbedJson() { Content = message.Content, Embed = new Embed() { Author = author, Thumbnail = thumbnail, Image = image, Footer = footer, Color = embed.Color.Value, Description = embed.Description, Fields = fields?.ToArray() ?? null, Timestamp = embed.Timestamp?.DateTime ?? DateTime.MinValue, Title = embed.Title, Url = embed.Url?.ToString() ?? null } }; return(result); }