public async Task <ulong> RepostMessageAsync(ITextChannel chan, IMessage msg, Embed embed = null)
{
using (DiscordWebhookClient webhook = await this.TryGetWebhookAsync(chan))
{
if (webhook == null)
{
return(0);
}
try
{
Embed[] embeds = embed == null ? null : new[] { embed };
if (msg.Attachments.Count > 0)
{
IAttachment attachment = msg.Attachments.First();
using (Stream stream = await this.HttpClient.GetStreamAsync(attachment.ProxyUrl))
return(await webhook.SendFileAsync(stream, attachment.Filename, msg.Content, false, embeds, msg.Author.Username, msg.Author.GetAvatarUrl()));
}
else
{
return(await webhook.SendMessageAsync(msg.Content, false, embeds, msg.Author.Username, msg.Author.GetAvatarUrl()));
}
}
catch (Exception ex)
{
this.Logger.Nice("Webhook", ConsoleColor.Red, $"Could not send a message: {ex.Message}");
return(0);
}
}
}
internal async Task Init()
{
PlatformRacing3Server.StartTime = Stopwatch.StartNew();
PlatformRacing3Server.ServerConfig = await JsonSerializer.DeserializeAsync <ServerConfig>(File.OpenRead("settings.json"));
RedisConnection.Init(PlatformRacing3Server.ServerConfig);
DatabaseConnection.Init(PlatformRacing3Server.ServerConfig);
await this.serverManager.LoadServersAsync();
await this.campaignManager.LoadCampaignTimesAsync();
await this.campaignManager.LoadPrizesAsync();
if (PlatformRacing3Server.ServerConfig.DiscordChatWebhookId != 0)
{
PlatformRacing3Server.DiscordChatWebhook = new DiscordWebhookClient(PlatformRacing3Server.ServerConfig.DiscordChatWebhookId, PlatformRacing3Server.ServerConfig.DiscordChatWebhookToken);
}
if (PlatformRacing3Server.ServerConfig.DiscordNotificationsWebhookId != 0)
{
PlatformRacing3Server.DiscordNotificationsWebhook = new DiscordWebhookClient(PlatformRacing3Server.ServerConfig.DiscordNotificationsWebhookId, PlatformRacing3Server.ServerConfig.DiscordNotificationsWebhookToken);
}
BytePacketManager bytePacketManager = new(this.serviceProvider);
this.listener = IListener.CreateTcpListener(new IPEndPoint(IPAddress.Parse(PlatformRacing3Server.ServerConfig.BindIp), PlatformRacing3Server.ServerConfig.BindPort), socket =>
{
socket.Pipeline.AddHandlerFirst(new SplitPacketHandler(bytePacketManager, new ClientSession(socket)));
socket.Pipeline.AddHandlerFirst(new FlashSocketPolicyRequestHandler());
}, this.serviceProvider);
_ = UpdateStatus();
}
public static async Task BroadcastResultsAsync(List <EndPointHealthResult> epResults, string discordWebhook, ILogger logger,
bool family = false)
{
bool errorDiscordClient = false;
DiscordWebhookClient client = null;
try
{
client = new DiscordWebhookClient(discordWebhook);
} catch (Exception e)
{
logger.LogInformation(e.Message);
errorDiscordClient = true;
}
List <Embed> embeds = null;
if (!family)
{
embeds = CreateClassicEmbeds(epResults);
}
else
{
embeds = CreateFamilyEmbeds(epResults);
}
if (!errorDiscordClient)
{
await client.SendMessageAsync(embeds : embeds, username : "******");
}
}
public static void PostMessage(string message, Action <string, bool> log, bool error = false)
{
using var client = new DiscordWebhookClient(error ? ConfigService.ErrorWebhookURL : ConfigService.WebhookURL);
client.Log += async arg =>
{
log.Invoke(arg.ToString(), false);
await Task.CompletedTask;
};
while (message.Length > 0)
{
string tempMessage = null;
if (message.Length >= 1900)
{
tempMessage = message.Substring(0, 1900);
message = message.Substring(1900);
}
else
{
tempMessage = message;
message = string.Empty;
}
client.SendMessageAsync(tempMessage).GetAwaiter().GetResult();
}
}
public static void loaded()
{
string desc = "Loaded the following feeds:";
foreach (RssFeed feed in Program.config.Feeds)
{
desc += "\n" + feed.FeedUrl;
}
var embed = new EmbedBuilder {
Title = "Bot loaded.",
Description = desc,
Timestamp = DateTime.Now
};
Embed compiled = embed.Build();
foreach (DiscordWebhook webhook in Program.config.Webhooks.Values)
{
if (webhook.SendDebuggingInfo)
{
using (var client = new DiscordWebhookClient(webhook.Endpoint)) {
client.SendMessageAsync(embeds: new Embed[] { compiled }).Wait();
}
}
}
}
public static void SendMessage(List <string> traces, string dpsReportPermalink, WebhookSettings settings)
{
if (settings.WebhookURL != null && settings.WebhookURL.Length > 0)
{
if (!dpsReportPermalink.Contains("https"))
{
traces.Add("Nothing to send to Webhook");
return;
}
try
{
var client = new DiscordWebhookClient(settings.WebhookURL);
try
{
if (settings.Embed == null)
{
_ = client.SendMessageAsync(text: dpsReportPermalink).Result;
}
else
{
_ = client.SendMessageAsync(embeds: new[] { settings.Embed }).Result;
}
traces.Add("Sent Embed");
}
finally
{
client.Dispose();
}
}
catch (Exception e)
{
traces.Add("Couldn't send embed: " + e.Message);
}
}
}
private async static Task EnviarMensagemDiscord(string mensagem, string urlDiscord, string urlCrowdin)
{
Console.WriteLine("Cria a conexão com o webhook");
var client = new DiscordWebhookClient(urlDiscord);
var message = new DiscordMessage
(
content: "Atualizações quentinhas saindo do forno para vocês <:kazupray:829517786509869057>",
username: "******",
avatarUrl: @"https://support.crowdin.com/assets/logos/crowdin-dark-symbol.png",
tts: false,
embeds: new []
{
new DiscordMessageEmbed
(
"Novas Atualizações",
0,
null,
urlCrowdin,
mensagem,
null,
null,
null,
null
)
}
);
Console.WriteLine($"Envia a mensagem para o Webhook: {mensagem} - {urlDiscord}");
await client.SendToDiscord(message);
Console.WriteLine($"mensagem enviada!");
}
public string SendMessage()
{
if (_webhookURLValid)
{
try
{
var client = new DiscordWebhookClient(_webhookURL);
try
{
if (_embed == null)
{
_ = client.SendMessageAsync(text: _message).Result;
}
else
{
_ = client.SendMessageAsync(embeds: new[] { _embed }).Result;
}
}
finally
{
client.Dispose();
}
return("Sent Embed");
}
catch (Exception e)
{
return("Couldn't send embed: " + e.Message);
}
}
return("Webhook url invalid");
}
public static void DeleteMessage(string webhookURL, ulong id, out string message)
{
if (IsWebhookURLValid(webhookURL))
{
try
{
var client = new DiscordWebhookClient(webhookURL);
try
{
client.DeleteMessageAsync(id).Wait();
}
finally
{
client.Dispose();
}
message = "Deleted message";
return;
}
catch (Exception e)
{
message = "Couldn't delete message: " + e.Message;
return;
}
}
message = "Webhook url invalid";
}
private async Task OnMessageReceived(SocketMessage message)
{
if (message.Source != MessageSource.User)
{
return;
}
if (message.Channel.Id != ChannelId)
{
return;
}
var authorId = message.Author.Id.ToString();
if (!Config.People.ContainsKey(authorId))
{
return;
}
string name = Config.People[authorId].Name;
string avatarUrl = Config.People[authorId].AvatarUrl;
using var webhookClient = new DiscordWebhookClient(WebhookUrl);
await webhookClient.SendMessageAsync(message.Content, username : name, avatarUrl : avatarUrl);
await message.DeleteAsync(DeleteMessageRequestOptions);
}
static DiscordBot()
{
Client = new DiscordSocketClient();
RazChannelWebhook = new DiscordWebhookClient(BotTools.Settings["raz_channel_webhook"]);
DJChannelWebhook = new DiscordWebhookClient(BotTools.Settings["dj_channel_webhook"]);
DJVettingChannelWebhook = new DiscordWebhookClient(BotTools.Settings["dj_vetting_webhook"]);
}
public static bool SendMessage(string webHookURL, string messageText, string userName = null, string avatarUrl = null)
{
DiscordWebhookClient discordWebhookClient = null;
try
{
discordWebhookClient = new DiscordWebhookClient(webHookURL);
}
catch (Exception ex)
{
throw new DiscordCommunications.Exceptions.DiscordClientInstantiationException("Failed to Instantiate DiscordWebhookClient", ex.InnerException);
}
try
{
////But a channel has a 30 msg/60 sec limit for webhooks
discordWebhookClient.SendMessageAsync(
text: messageText,
username: userName,
avatarUrl: avatarUrl
);
}
catch (Exception)
{
return(false);
}
return(true);
}
public static bool SendMessage(MessageOptions options)
{
DiscordWebhookClient discordWebhookClient = null;
try
{
discordWebhookClient = new DiscordWebhookClient(options.WebHookURL);
}
catch (Exception ex)
{
throw new DiscordCommunications.Exceptions.DiscordClientInstantiationException("Failed to Instantiate DiscordWebhookClient", ex.InnerException);
}
try
{
////But a channel has a 30 msg/60 sec limit for webhooks
discordWebhookClient.SendMessageAsync(
text: options.Text,
isTTS: options.IsTTS,
embeds: options.Embeds,
username: options.Username,
avatarUrl: options.AvatarUrl,
options: options.Options);
}
catch (Exception)
{
return(false);
}
return(true);
}
public static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
{
services.AddSingleton <Startup>();
services.AddHostedService <PinsService>();
services.AddDbContext <PinsDbContext>(builder =>
{
builder.UseSqlite(context.Configuration["Database:ConnectionString"])
.ConfigureWarnings(c => c.Log((RelationalEventId.CommandExecuting, MSLogLevel.Debug)));
});
var discordConfig = new DiscordConfiguration()
{
Token = context.Configuration["Discord:Token"], LogLevel = LogLevel.Debug
};
var discord = new DiscordClient(discordConfig);
services.AddSingleton(discord);
var webhookClient = new DiscordWebhookClient();
services.AddSingleton(webhookClient);
var prefixes = context.Configuration["Discord:Prefixes"].Split(' ', StringSplitOptions.RemoveEmptyEntries);
var commandsConfig = new CommandsNextConfiguration()
{
Services = services.BuildServiceProvider(), StringPrefixes = prefixes
};
var cnext = discord.UseCommandsNext(commandsConfig);
services.AddSingleton(cnext);
}
public void TestWebhook_Valid(string webhookurl, ulong expectedId, string expectedToken)
{
DiscordWebhookClient.ParseWebhookUrl(webhookurl, out ulong id, out string token);
Assert.Equal(expectedId, id);
Assert.Equal(expectedToken, token);
}
public static ulong SendMessage(string webhookURL, string embed, out string message)
{
if (IsWebhookURLValid(webhookURL))
{
try
{
var client = new DiscordWebhookClient(webhookURL);
ulong id;
try
{
id = client.SendMessageAsync(text: embed).Result;
}
finally
{
client.Dispose();
}
message = "Sent Embed";
return(id);
}
catch (Exception e)
{
message = "Couldn't send embed: " + e.Message;
return(0);
}
}
message = "Webhook url invalid";
return(0);
}
public void TestWebhook_Invalid(string webhookurl)
{
Assert.Throws <ArgumentException>(() =>
{
DiscordWebhookClient.ParseWebhookUrl(webhookurl, out ulong id, out string token);
});
}
public async Task RunAsync(Action <string> logAction = null)
{
this.logAction = logAction;
// 最後に観測した日時をTableから取得する。これより新しいつぶやきのみ通知する。、
var lastObservedAt = GetLastObservedAt();
Log($"lastObservedAt ={lastObservedAt }");
var voiceItems = await GetVoiceItemsAsync();
var newVoiceItems = voiceItems.Where(x => x.PostTime > lastObservedAt);
var newComments = voiceItems
.SelectMany(x => x.Response)
.Where(x => x.PostTime > lastObservedAt);
var client = new DiscordWebhookClient(discordWebhookId, discordWebhookToken);
// 新着ボイスを通知
await NotifyVoices(newVoiceItems, client);
// 新着コメントを通知
await NotifyComments(newComments, client);
await UpdateLastObservedAtAsync();
}
public async Task SendMessage(DiscordWebhookClient webhook,
Proxy proxy,
string text,
IReadOnlyCollection <IAttachment> attachments)
{
var proxyUser = discord.GetUser(proxy.BotUser.DiscordId);
var username = $"{proxy.Name} [{proxyUser.Username}]";
var avatarUrl = proxy.HasAvatar
? $"{avatarBaseUrl}/{proxy.AvatarGuid}"
: proxyUser.GetAvatarUrl();
if (attachments?.Any() ?? false)
{
var first = true;
foreach (var a in attachments)
{
// TODO: Single multipart request
var stream = await new HttpClient().GetStreamAsync(a.Url);
await webhook.SendFileAsync(stream, a.Filename, first?text : String.Empty,
username : username,
avatarUrl : avatarUrl);
first = false;
}
}
else
{
await webhook.SendMessageAsync(text,
username : username,
avatarUrl : avatarUrl);
}
}
public async Task Upload(string comment, string filepath, string url)
{
using (var client = new DiscordWebhookClient(url))
{
await client.SendFileAsync(text : comment, filePath : filepath);
}
}
public async Task Send(Giveaway giveaway, string webhook)
{
using (var client = new DiscordWebhookClient(webhook))
{
var embed = new EmbedBuilder
{
Title = giveaway.Title,
Color = Color.Magenta,
ImageUrl = giveaway.PhotoUrl,
Url = string.IsNullOrEmpty(giveaway.DirectUrl) ? giveaway.Url : giveaway.DirectUrl,
Author = new EmbedAuthorBuilder().WithName(giveaway.Store)
};
try
{
await client.SendMessageAsync(
text : $"@everyone \n its free real estate \n add notifier to your [discord server]({MongoConfig.clientUrl})",
embeds : new[] { embed.Build() },
isTTS : true
);
}
catch (Exception e)
{
throw new DiscordSendException($"failed to send giveaway {giveaway.ExternalId}", e);
}
finally
{
await _giveawayRepository.UpdateStatus(giveaway);
}
}
}
public async Task SendPunishmentWebhook(int punishmentId)
{
PlayerPunishment punishment = database.GetPunishment(punishmentId);
if (punishment == null)
{
return;
}
using (var client = new DiscordWebhookClient(webhookUrl))
{
EmbedBuilder eb = new EmbedBuilder();
eb.WithColor(Color.Blue);
eb.WithTitle($"{CultureInfo.CurrentCulture.TextInfo.ToTitleCase(punishment.Category)}");
eb.AddField("Player", $"[{punishment.Player.PlayerName}](https://steamcommunity.com/profiles/{punishment.PlayerId})");
eb.AddField("Punisher", $"[{punishment.Punisher.PlayerName}](https://steamcommunity.com/profiles/{punishment.PunisherId})");
eb.AddField("Reason", punishment.Reason == null ? "unkown" : punishment.Reason);
if (punishment.ExpiryDate.HasValue)
{
eb.AddField("Expires", punishment.ExpiryDate);
}
eb.WithTimestamp(punishment.CreateDate);
await client.SendMessageAsync(embeds : new List <Embed>()
{
eb.Build()
});
}
}
public void StartReadEngine()
{
if (File.Exists("data/potterhead.garden"))
{
Webhook = new DiscordWebhookClient(File.ReadAllText("data/potterhead.garden"));
if (!Directory.Exists("data/book/"))
{
Directory.CreateDirectory("data/book/");
}
if (File.Exists("data/book/lastreadtime.garden"))
{
LastReadTime = DateTime.Parse(File.ReadAllText("data/book/lastreadtime.garden"));
}
else
{
LastReadTime = DateTime.UtcNow;
}
}
else
{
File.Create("data/potterhead.garden");
Console.WriteLine("Please paste the PotterHead link in the data/potterhead.garden file!");
}
}
private static void NotifyNewPosts(RssFeed feed, List <Post> posts)
{
for (int i = 0; i < posts.Count; i += 10) //max 10 embeds per webhook push
{
List <Embed> embeds = new List <Embed>();
for (int k = i; k < Math.Min(i + 10, posts.Count); k++)
{
Post p = posts.ElementAt(k);
embeds.Add(p.Embed);
if (config.OutputToConsole)
{
Console.WriteLine($"\n{p.Title}");
Console.WriteLine($"Posted in /r/{p.Subreddit} by /u/{p.Author}");
Console.WriteLine($"Timestamp: {p.PublishDate}");
Console.WriteLine($"URL: {p.Url}");
if (p.HasImage)
{
Console.WriteLine($"Image URL: {p.ImageUrl}");
}
}
}
foreach (String target in feed.WebhookTargets)
{
DiscordWebhook webhook = config.Webhooks[target];
using (var client = new DiscordWebhookClient(webhook.Endpoint)) {
client.SendMessageAsync(text: webhook.PingString.Length > 0 ? webhook.PingString : null, embeds: embeds).Wait();
}
}
}
}
public static void SendMessage(ParsedLog log, string[] uploadresult)
{
if (Properties.Settings.Default.WebhookURL != null && Properties.Settings.Default.WebhookURL.Length > 0)
{
if (!uploadresult[0].Contains("https"))
{
log.UpdateProgressWithCancellationCheck("Nothing to send to Webhook");
return;
}
try
{
var client = new DiscordWebhookClient(Properties.Settings.Default.WebhookURL);
try
{
if (Properties.Settings.Default.SendSimpleMessageToWebhook)
{
_ = client.SendMessageAsync(text: uploadresult[0]).Result;
}
else
{
_ = client.SendMessageAsync(embeds: new[] { GetEmbed(log, uploadresult) }).Result;
}
log.UpdateProgressWithCancellationCheck("Sent Embed");
}
finally
{
client.Dispose();
}
}
catch (Exception e)
{
log.UpdateProgressWithCancellationCheck("Couldn't send embed: " + e.GetFinalException().Message);
}
}
}
public static async Task BroadcastErrorAsync(string discordWebhook, ILogger logger)
{
bool errorDiscordClient = false;
DiscordWebhookClient client = null;
try
{
client = new DiscordWebhookClient(discordWebhook);
} catch (Exception e)
{
logger.LogInformation(e.Message);
errorDiscordClient = true;
}
Color embedColor = Color.Red;
EmbedBuilder builder = new EmbedBuilder();
var b = builder.WithTitle("Latency Alert")
.WithDescription("⚠ There have been a connexion issue, it will restart. If this problem persists, please contact administrator.")
.WithColor(embedColor)
.Build();
List <Embed> embeds = new List <Embed>()
{
b
};
if (!errorDiscordClient)
{
await client.SendMessageAsync(embeds : embeds, username : "******");
}
}
private async Task SendEmojiWithName(string name)
{
string emoji = name switch
{
"sans" => "<a:sans:719488632104288286>",
"thonk" => "<:thonk:718853430969368637>",
"mindblowing" => "<:mindblowing:719492411369324584>",
"rotatethink" => "<a:rotatethonk:719491269885427752>",
"hyper" => "<a:hyper:719494595313926244>",
"xd" => "<:xd:719510255402352690>",
"rainbowcat" => "<a:catrainbow1:719513824511656037><a:catrainbow2:719513824553861121>\n<a:catrainbow3:719513824905920603><a:catrainbow4:719513825040400415>",
"yes" => "<a:yes:719496630902063149>",
"no" => "<a:no:719496639471157288>",
"calculated" => "<:calculated:719518217730654218>",
_ => "unknown"
};
var cxt = base.Context;
var webhook = await((ITextChannel)cxt.Channel).CreateWebhookAsync(((IGuildUser)cxt.User).Nickname ?? cxt.User.Username);
var webhookClient = new DiscordWebhookClient(webhook);
await cxt.Channel.DeleteMessageAsync(base.Context.Message);
await webhookClient.SendMessageAsync(emoji, avatarUrl : cxt.User.GetAvatarUrl());
await webhookClient.DeleteWebhookAsync();
}
}
private async void bSend_Click(object sender, EventArgs e)
{
var match = regexWebhook.Match(tbFullWebhook.Text);
if (!match.Success)
{
return;
}
var hook = new DiscordWebhookClient(ulong.Parse(match.Groups[1].Value), match.Groups[2].Value);
var embed = new EmbedBuilder();
embed.WithDescription(tbBodyMessage.Text);
var cnt = 0;
if (cbUseColor.Checked && ++cnt > 0)
{
embed.WithColor(new Color(pColor.BackColor.R, pColor.BackColor.G, pColor.BackColor.B));
}
if (!string.IsNullOrEmpty(tbTitle.Text) && ++cnt > 0)
{
embed.WithTitle(tbTitle.Text);
}
if (!string.IsNullOrEmpty(tbThumbnailUrl.Text) && ++cnt > 0)
{
embed.WithThumbnailUrl(tbThumbnailUrl.Text);
}
if (!string.IsNullOrEmpty(tbImageUrl.Text) && ++cnt > 0)
{
embed.WithImageUrl(tbImageUrl.Text);
}
if (!string.IsNullOrEmpty(tbLink.Text) && ++cnt > 0)
{
embed.WithUrl(tbLink.Text);
}
if (dtpTimestamp.Checked && ++cnt > 0)
{
embed.WithTimestamp(new DateTimeOffset(dtpTimestamp.Value.ToUniversalTime()));
}
if (!string.IsNullOrEmpty(tbAuthorName.Text) && ++cnt > 0)
{
embed.WithAuthor(tbAuthorName.Text
, !string.IsNullOrEmpty(tbAuthorAvatarUrl.Text) ? tbAuthorAvatarUrl.Text : null
, !string.IsNullOrEmpty(tbAuthorLink.Text) ? tbAuthorLink.Text : null);
}
if (!string.IsNullOrEmpty(tbFooterText.Text) && ++cnt > 0)
{
embed.WithFooter(tbFooterText.Text
, !string.IsNullOrEmpty(tbFooterIconUrl.Text) ? tbFooterIconUrl.Text : null);
}
if (cnt > 0)
{
await hook.SendMessageAsync("", false, new[] { embed.Build() }, tbSenderName.Text,
tbSenderAvatarUrl.Text);
}
else
{
await hook.SendMessageAsync(tbBodyMessage.Text, false, null, tbSenderName.Text, tbSenderAvatarUrl.Text);
}
}
private void Test(object sender, RoutedEventArgs e)
{
try {
DiscordWebhookClient s = new DiscordWebhookClient(hook.Text);
var embed = new EmbedBuilder
{
Title = "Zen Aio Webhook Test Results",
Description = "Testing.."
};
embed.AddField("Product",
"Yeezy 350 V2")
.WithFooter(footer => footer.Text = "Zen Aio")
//.WithFooter(footer => )
.WithColor(Discord.Color.Blue)
.WithCurrentTimestamp()
.WithImageUrl("https://www.flightclub.com/media/catalog/product/cache/1/image/1600x1140/9df78eab33525d08d6e5fb8d27136e95/2/0/201519_1.jpg")
.Build();
embed.Footer.IconUrl = "https://cdn.discordapp.com/attachments/561322271935823893/580919251670663168/Zen.jpg";
s.SendMessageAsync(text: "COPPED!", embeds: new[] { embed.Build() });
}
catch
{
MessageBox.Show("Error on the webhook");
}
}
private DiscordWebhookClient GetWebhook()
{
if (webhook == null)
{
webhook = new DiscordWebhookClient(this.Id, this.Token);
}
return(webhook);
}
