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 async static void SendWebHook(string joinTime, string link)
{
// Checks if discord web link exists in settings.json if not then dont send webhook
if (string.IsNullOrWhiteSpace(discordWebhookLink))
{
return;
}
try
{
var client = new DiscordWebhookClient(discordWebhookLink);
// Create your DiscordMessage with all parameters of your message.
var message = new DiscordMessage(
DateTime.Now.ToString("MMM dd, yyyy HH:mm:ss tt"),
username: "******",
avatarUrl: "https://www.publiccounsel.net/train/wp-content/uploads/sites/13/5e8ce318664eae0004085461.png",
tts: false,
embeds: new[]
{
new DiscordMessageEmbed(
"Current Logs",
color: 0,
author: new DiscordMessageEmbedAuthor("By smashguns#6175"),
//url: "https://www.publiccounsel.net/train/wp-content/uploads/sites/13/5e8ce318664eae0004085461.png",
//description: "This is a embed description.",
fields: new[]
{
new DiscordMessageEmbedField("Joined Time", MilitaryToAmPm(Convert.ToDateTime(joinTime))),
new DiscordMessageEmbedField("Link", link)
},
footer: new DiscordMessageEmbedFooter("Made by smashguns#6175 • " + DateTime.Now, "https://cdn.discordapp.com/avatars/242889488785866752/40ee66d845e1a6341e03c450fcf6d221.png?size=256")
)
}
);
await client.SendToDiscord(message);
}
catch (Exception ex)
{
throwErr("Discord Webhook Error!\n" + ex.Message);
}
}
static void Main(string[] args)
{
// Create default config file if it doesn't exist
if (!File.Exists("config.cfg"))
{
var c = new Configuration
{
new Section("General")
{
{ "subreddit", "market_subreddit_name" },
{ "webhook", "https://discordapp.com/api/webhooks/..." }
}
};
c.SaveToFile("config.cfg");
}
// Load configuration
var config = Configuration.LoadFromFile("config.cfg");
var configGeneral = config["General"];
var webhook = configGeneral["webhook"].StringValue;
var subreddit = configGeneral["subreddit"].StringValue;
// Load webhook handler
var discord = new DiscordWebhookClient(webhook);
// Load market entry cache database
var cacheDb = new LiteDatabase("cachedposts.db");
var cachedEntries = cacheDb.GetCollection <MarketEntry>();
cachedEntries.EnsureIndex(entry => entry.Id, true);
// Load the most recent subreddit posts
SubredditNewPosts sub;
using (var wc = new WebClient())
sub = JsonConvert.DeserializeObject <SubredditNewPosts>(wc.DownloadString($"https://www.reddit.com/r/{subreddit}/new.json"));
// Create title-matching regex
var regex = new Regex("\\[(?<location>.*?)\\]\\s*\\[H\\](?<have>.*)\\[W\\](?<want>.+)", RegexOptions.Compiled);
// Select "buying" posts which have a correct title format
var marketEntries =
sub.Subreddit.SubredditPosts
.Where(post => post.Post.LinkFlairCssClass == "selling" && regex.IsMatch(post.Post.Title))
.Select(post => (post, matches: regex.Match(post.Post.Title)))
.Select(tuple => new MarketEntry(
tuple.post.Post.Author,
tuple.matches.Groups["have"].Value.Trim(),
tuple.matches.Groups["want"].Value.Trim(),
tuple.matches.Groups["location"].Value.Trim(),
UnixTimeStampToDateTime(tuple.post.Post.Created),
tuple.post.Post.Id,
tuple.post.Post.Permalink
))
.Where(entry => !cachedEntries.Exists(marketEntry => marketEntry.Id == entry.Id));
foreach (var post in marketEntries)
{
var message = new DiscordMessage
{
Embeds = new[]
{
new DiscordMessageEmbed
{
Color = 0x5b92fa,
Url = $"https://reddit.com{post.Permalink}",
Title = $"New listing by {post.Author} in {post.Location}",
Fields = new[]
{
new DiscordMessageEmbedField
{
Name = "Have",
Value = post.Have
},
new DiscordMessageEmbedField
{
Name = "Want",
Value = post.Want
}
}
}
}
};
discord.SendToDiscord(message);
cachedEntries.Insert(post);
}
}
public async Task Should_Send_Hello_World_Message()
{
var message = new DiscordMessage("Hello World!");
await _client.SendToDiscord(message);
Assert.IsTrue(true);
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
var client = new DiscordWebhookClient(_options.WebhookUrl);
DiscordMessage message = null;
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
var formattedMessage = formatter(state, exception);
if (string.IsNullOrEmpty(formattedMessage))
{
return;
}
var messageContent = string.Empty;
int?messageEmbedColor = null;
switch (logLevel)
{
case LogLevel.None:
case LogLevel.Trace:
messageContent = $"**{logLevel}**: {formattedMessage}";
break;
case LogLevel.Debug:
messageContent = $"{DiscordEmoji.SpiderWeb} **{logLevel}**: {formattedMessage}";
break;
case LogLevel.Information:
messageContent = $"{DiscordEmoji.InformationSource} **{logLevel}**: {formattedMessage}";
messageEmbedColor = (int)DiscordColor.Blue;
break;
case LogLevel.Warning:
messageContent = $"{DiscordEmoji.Warning} **{logLevel}**: {formattedMessage}";
messageEmbedColor = (int)DiscordColor.Yellow;
break;
case LogLevel.Critical:
messageContent = $"{DiscordEmoji.Radioactive} **{logLevel}**: {formattedMessage}";
messageEmbedColor = 16711680;
break;
case LogLevel.Error:
messageContent = $"{DiscordEmoji.Skull} **{logLevel}**: {formattedMessage}";
messageEmbedColor = (int)DiscordColor.Red;
break;
}
var fields = new List <DiscordMessageEmbedField>();
if (!string.IsNullOrEmpty(_options.ApplicationName))
{
fields.Add(new DiscordMessageEmbedField("Application name", _options.ApplicationName));
}
if (!string.IsNullOrEmpty(_options.EnvironmentName))
{
fields.Add(new DiscordMessageEmbedField("Environment name", _options.EnvironmentName));
}
if (_httpContextAcessor?.HttpContext?.User != null && _options.UserClaimValueToDiscordFields.Count > 0)
{
foreach (var item in _options.UserClaimValueToDiscordFields.Where(x => !string.IsNullOrEmpty(x.DiscordFieldName)))
{
var claimValue = _httpContextAcessor?.HttpContext?.User?.Claims?.FirstOrDefault(x => x.Type == item.ClaimType)?.Value;
fields.Add(new DiscordMessageEmbedField(item.DiscordFieldName, claimValue));
}
}
var files = new List <DiscordFile>();
DiscordMessageEmbed embed = null;
if (exception != null)
{
fields.Add(new DiscordMessageEmbedField("Exception type", exception.GetType().ToString()));
fields.Add(new DiscordMessageEmbedField("Source", exception.Source));
var exceptionInfoText = new StringBuilder();
exceptionInfoText.Append("Message: ").AppendLine(exception.Message);
exceptionInfoText.Append("Exception type: ").AppendLine(exception.GetType().ToString());
exceptionInfoText.Append("Source: ").AppendLine(exception.Source);
exceptionInfoText.Append("Base exception: ").AppendLine(exception.GetBaseException()?.Message);
foreach (DictionaryEntry data in exception.Data)
{
exceptionInfoText.Append(data.Key).Append(": ").Append(data.Value).AppendLine();
}
exceptionInfoText.Append("Stack trace: ").AppendLine(exception.StackTrace);
if (_httpContextAcessor?.HttpContext?.Request != null)
{
var uriBuilder = new UriBuilder
{
Scheme = _httpContextAcessor.HttpContext.Request.Scheme,
Host = _httpContextAcessor.HttpContext.Request.Host.Host,
Path = _httpContextAcessor.HttpContext.Request.Path.ToString(),
Query = _httpContextAcessor.HttpContext.Request.QueryString.ToString()
};
if (_httpContextAcessor.HttpContext.Request.Host.Port.HasValue && _httpContextAcessor.HttpContext.Request.Host.Port.Value != 80)
{
uriBuilder.Port = _httpContextAcessor.HttpContext.Request.Host.Port.Value;
}
if (!string.IsNullOrEmpty(uriBuilder.Host))
{
fields.Add(new DiscordMessageEmbedField("URL", uriBuilder.Uri.ToString()));
}
var requestHeaders = new Dictionary <string, string>();
foreach (var item in _httpContextAcessor.HttpContext.Request.Headers?.Where(x => x.Key != "Cookie" && x.Value.Count > 0))
{
requestHeaders.Add(item.Key, string.Join(",", item.Value.ToArray()));
}
if (requestHeaders.Count > 0)
{
exceptionInfoText.AppendLine("Request headers:").AppendLine(JsonConvert.SerializeObject(requestHeaders, Formatting.Indented));
}
}
files.Add(new DiscordFile("exception-details.txt", Encoding.UTF8.GetBytes(exceptionInfoText.ToString())));
embed = new DiscordMessageEmbed(color: messageEmbedColor, description: $"**{exception.Message}**", fields: fields.Count > 0 ? fields.ToArray() : null);
}
else if (fields.Count > 0)
{
embed = new DiscordMessageEmbed(color: messageEmbedColor, fields: fields.ToArray());
}
message = new DiscordMessage(messageContent, _options.UserName, embeds: embed != null ? new[] { embed } : null);
if (files.Count > 0)
{
client.SendToDiscord(message, files.ToArray(), true).Wait();
}
else
{
client.SendToDiscord(message, true).Wait();
}
}
