private static string SendToSlack(
SlackPayload o,
string slackHookUrl)
{
try
{
var hookJson = JsonConvert.SerializeObject(o, Formatting.None);
Log.Information("Posting Slack json {slackMessageJson} to {SlackWebHookUrl}", hookJson, slackHookUrl);
var httpWebRequest = (HttpWebRequest)WebRequest.Create(slackHookUrl);
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
httpWebRequest.Timeout = 30000;
httpWebRequest.ReadWriteTimeout = 30000;
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
streamWriter.Write(hookJson);
streamWriter.Flush();
}
using (var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse())
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
return(streamReader.ReadToEnd());
}
}
catch (Exception e)
{
Log.Error(e, "Failed to send message to Slack.");
throw;
}
}
private SlackPayload CreatePayload(string message, List <Attachment> attachments = null)
{
var icon = Settings.Icon;
var channel = Settings.Channel;
var payload = new SlackPayload
{
Username = Settings.Username,
Text = message,
Attachments = attachments
};
if (icon.IsNotNullOrWhiteSpace())
{
// Set the correct icon based on the value
if (icon.StartsWith(":") && icon.EndsWith(":"))
{
payload.IconEmoji = icon;
}
else
{
payload.IconUrl = icon;
}
}
if (channel.IsNotNullOrWhiteSpace())
{
payload.Channel = channel;
}
return(payload);
}
public IActionResult SlackImagePost(int i)
{
var req = this.HttpContext.Request.Form;
byte[] myFileContent;
myFileContent = EbFile.Bytea_FromFile("F://1.jpg");
SlackPayload payload = new SlackPayload
{
Channel = req["Channel"],
Text = req["Content"],
SlackFile = new SlackFile
{
FileName = req["FileName"],
FileByte = myFileContent,
FileType = req["FileType"],
}
};
this.ServiceClient.Post(new SlackPostRequest {
Payload = payload, PostType = 1
});
return(View());
}
private static SlackPayload BuildSlackPayload(string message,
string username,
string category,
OctopusSubscriptionEvent octopusEvent)
{
var slackChannelName = Util.GetEnvironmentVariable("SLACK_CHANNEL_NAME");
if (string.IsNullOrWhiteSpace(slackChannelName))
{
throw new InvalidOperationException("SLACK_CHANNEL_NAME is not set!");
}
var slackMsg = new SlackPayload
{
Channel = slackChannelName,
Attachments = new List <Attachment>
{
new Attachment
{
Color = "#5C91DC",
Fallback = message,
Footer = username,
FooterIcon =
"https://emojipedia-us.s3.amazonaws.com/thumbs/240/microsoft/106/face-with-cowboy-hat_1f920.png",
Pretext = category,
Text = message,
SecondsSinceUnixEpoch = ToUnixTime(octopusEvent.Payload.Event.Occurred.ToUniversalTime())
}
}
};
return(slackMsg);
}
private void AddHealthAttachments(
HealthCheckStatus checkStatus,
IReadOnlyCollection <HealthCheck.Result> checks,
SlackPayload slackMessage,
bool reFailure = false)
{
var checkOrChecks = checks.Count > 1 ? "checks" : "check";
var textEnd = string.Empty;
var color = string.Empty;
if (checkStatus == HealthCheckStatus.Unhealthy)
{
textEnd = reFailure ? "still failing" : "failing";
color = FailingColor;
}
if (checkStatus == HealthCheckStatus.Degraded)
{
textEnd = reFailure ? "still degrading" : "degrading";
color = DegradingColor;
}
if (checkStatus == HealthCheckStatus.Healthy)
{
textEnd = "recovered";
color = SuccessColor;
}
var attachment = new SlackAttachment
{
Text = $"*_{checks.Count} {checkOrChecks} {textEnd}_ on server {Environment.MachineName}*\n\n",
Color = color,
Ts = (DateTime.UtcNow - Epoch).TotalSeconds
};
foreach (var result in checks)
{
if (result.Check.Status == HealthCheckStatus.Unhealthy)
{
LastDegradedCheckCache.Remove(result.Name);
LastUnhealthyCheckCache.Add(result.Name);
}
else if (result.Check.Status == HealthCheckStatus.Degraded)
{
LastUnhealthyCheckCache.Remove(result.Name);
LastDegradedCheckCache.Add(result.Name);
}
attachment.Fields.Add(
new SlackAttachmentFields
{
Title = $"{result.Name}",
Value = $"```{result.Check.Message}```",
Short = true
});
}
slackMessage.Attachments.Add(attachment);
}
public string PostMessage(string text, string channel = null)
{
var payload = new SlackPayload
{
Channel = channel,
Text = text
}; return(PostMessage(payload));
}
private SlackPayload CreatePayloadFromReservationInformation(string slackChannel, int totalReservations)
{
var payload = new SlackPayload()
{
Channel = slackChannel,
Text = $"{totalReservations} prepaid reservations done in the last 5 minutes"
};
return(payload);
}
// POST: api/Fullwidth
// The POST on this controller outputs a Slack-consumable JSON.
// WebAPI doesn't play nice with the formatting of Slack's application/x-www-form-urlencoded with the [FromBody] prop- resulting in a null in value.
//The solution was to accept the incoming HTTP POST as a HttpRequestMessage, then extract the data from the request.Content.
public SlackMessage Post(/*[FromBody]string value*/ HttpRequestMessage request)
{
//process the HTML post body and process it in a SlackPayload
SlackPayload inSlack = new SlackPayload(request.Content.ReadAsStringAsync().Result);
//send out a new slack message
SlackMessage message = new SlackMessage(FullwidthConverter.convert(inSlack.text), "AestheticBot", true, SlackMessage.in_channel);
return(message);
}
private string PostMessage(SlackPayload payload)
{
var payloadJson = JsonConvert.SerializeObject(payload);
using var client = new WebClient();
var data = new NameValueCollection {
["payload"] = payloadJson
};
var response = client.UploadValues(_uri, "POST", data);
return(_encoding.GetString(response));
}
//Post a message
public void PostMessage(string additionalInformation, Exception ex)
{
SlackPayload payload = new SlackPayload()
{
Text = $"🔥 {additionalInformation} 🔥",
Attachments = new List <SlackPayload.Attach>()
};
payload.Attachments.AddRange(GetSlackAttachmentList(ex));
PostMessage(payload);
}
public static Task SendNotification(Post post, string websiteUrl)
{
if (!string.IsNullOrEmpty(ConfigurationHelper.Instance.SlackHook))
{
var payload = new SlackPayload
{
Text = string.Format(
MessageTemplate,
ConfigurationHelper.Instance.ProductName,
$"{websiteUrl}/Posts/View/{post.PostId}"),
Username = ConfigurationHelper.Instance.ProductName,
Icon = ConfigurationHelper.Instance.ProductFavicon
};
Attachment attachment = null;
if (post.Image != null)
{
#if DEBUG
// Slack won't display images from "localhost". Jeez...
attachment = new Attachment(
"Preview",
ConfigurationHelper.Instance.ProductLogo,
post.Title);
#else
attachment = new Attachment(
"Preview",
$"{websiteUrl}/jpg/Images/View/{post.Image.ImageId}.jpg",
post.Title);
#endif
}
else
{
attachment = new Attachment(
"Preview",
post.YouTubeLink.GetYoutubeThumbnail(),
post.Title,
"This is a youtube video",
"https://cdn1.iconfinder.com/data/icons/google_jfk_icons_by_carlosjj/512/youtube.png");
}
if (attachment != null)
{
payload.Attachments.Add(attachment);
}
using (var client = new HttpClient())
{
var result = client.PostAsJsonAsync(ConfigurationHelper.Instance.SlackHook, payload).Result;
}
}
return(null);
}
public void SendMessage(SlackPayload payload, string token)
{
var uri = new Uri(token);
string payloadJson = JsonConvert.SerializeObject(payload);
using (WebClient client = new WebClient())
{
NameValueCollection data = new NameValueCollection();
data["payload"] = payloadJson;
client.UploadValues(uri, "POST", data);
}
}
public async Task PostMessage(SlackModel model)
{
var payload = new SlackPayload
{
Channel = model.Channel,
Username = model.Username,
Emojii = model.Emoji,
mrkdwn = true,
Text = model.Message,
};
await PostMessage(payload);
}
public void PostMessage()
{
string urlWithAccessToken = ""; // Use your slack webhook here : D
SlackClient client = new SlackClient();
SlackPayload payload = new SlackPayload()
{
Channel = "avengers",
Text = "Here we go!",
};
client.SendMessage(payload, urlWithAccessToken);
}
public IActionResult SlackTextPost(int i)
{
var req = this.HttpContext.Request.Form;
SlackPayload payload = new SlackPayload
{
Channel = req["Channel"],
Text = req["Text"],
};
this.ServiceClient.Post(new SlackPostRequest {
Payload = payload, PostType = 0
});
return(View());
}
public void GivenNotGivenPropertiesTheyAreNotIncluded()
{
var payload = new SlackPayload()
{
Channel = "FOOBAR",
Blocks = new List <IBlock>()
{
new Section(new SectionText("SectionText"), null, null)
}
};
var serialized = payload.Serialize();
serialized
.Should()
.NotContain("fields");
}
private async Task PostMessage(SlackPayload slackPayload)
{
string payloadJson = JsonConvert.SerializeObject(slackPayload);
try
{
var res = await HttpClient.PostAsync(_uri, new StringContent(payloadJson, Encoding.UTF8, "application/json"));
if (!res.IsSuccessStatusCode)
{
_logger.LogInformation(JsonConvert.SerializeObject(res));
}
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
}
public override void OnRename(Series series)
{
var payload = new SlackPayload
{
IconEmoji = Settings.Icon,
Username = Settings.Username,
Text = "Renamed",
Attachments = new List <Attachment>
{
new Attachment
{
Title = series.Title,
}
}
};
NotifySlack(payload);
}
private void NotifySlack(SlackPayload payload)
{
try
{
var client = RestClientFactory.BuildClient(Settings.WebHookUrl);
var request = new RestRequest(Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new JsonNetSerializer()
};
request.AddBody(payload);
client.ExecuteAndValidate(request);
}
catch (RestException ex)
{
_logger.Error(ex, "Unable to post payload {0}", payload);
throw new SlackExeption("Unable to post payload", ex);
}
}
public async Task <SlackResponse> UpdateMessage(SlackPayload payload)
{
var httpContent = new StringContent(payload.Serialize(), Encoding.UTF8, "application/json");
var request = _httpClient.PostAsync("/api/chat.update", httpContent);
var response = await request.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
var body = await response.Content.ReadAsStringAsync();
var responseBody = JsonConvert.DeserializeObject <SlackResponse>(body);
if (responseBody.Ok)
{
return(responseBody);
}
throw new SlackClientException(responseBody.Error);
}
return(null);
}
//Post a message using a Payload object
private void PostMessage(SlackPayload payload)
{
try
{
string payloadJson = JsonConvert.SerializeObject(payload);
using (WebClient client = new WebClient())
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
NameValueCollection data = new NameValueCollection();
data["payload"] = payloadJson;
var response = client.UploadValues(_uri, "POST", data);
string responseText = _encoding.GetString(response);
}
}
catch
{
//don't do anything with the exception here in this Slack Client...
}
}
public string PostMessage(string message)
{
SlackPayload payload = new SlackPayload()
{
Text = message
};
string payloadJson = JsonConvert.SerializeObject(payload);
using (WebClient client = new WebClient())
{
NameValueCollection data = new NameValueCollection();
data["payload"] = payloadJson;
var response = client.UploadValues(_uri, "POST", data);
//The response text is usually "ok"
return(_encoding.GetString(response));
}
}
public void SendPayload(SlackPayload payload, SlackSettings settings)
{
try
{
var request = new HttpRequestBuilder(settings.WebHookUrl)
.Accept(HttpAccept.Json)
.Build();
request.Method = HttpMethod.POST;
request.Headers.ContentType = "application/json";
request.SetContent(payload.ToJson());
_httpClient.Execute(request);
}
catch (RestException ex)
{
_logger.Error(ex, "Unable to post payload {0}", payload);
throw new SlackExeption("Unable to post payload", ex);
}
}
public override void OnDownload(DownloadMessage message)
{
var payload = new SlackPayload
{
IconEmoji = Settings.Icon,
Username = Settings.Username,
Text = $"Imported: {message.Message}",
Attachments = new List <Attachment>
{
new Attachment
{
Fallback = message.Message,
Title = message.Series.Title,
Text = message.Message,
Color = "good"
}
}
};
NotifySlack(payload);
}
public override void OnGrab(GrabMessage message)
{
var payload = new SlackPayload
{
IconEmoji = Settings.Icon,
Username = Settings.Username,
Text = $"Grabbed: {message.Message}",
Attachments = new List <Attachment>
{
new Attachment
{
Fallback = message.Message,
Title = message.Series.Title,
Text = message.Message,
Color = "warning"
}
}
};
NotifySlack(payload);
}
public ValidationFailure TestMessage()
{
try
{
var message = $"Test message from Sonarr posted at {DateTime.Now}";
var payload = new SlackPayload
{
IconEmoji = Settings.Icon,
Username = Settings.Username,
Text = message
};
NotifySlack(payload);
}
catch (SlackExeption ex)
{
return(new NzbDroneValidationFailure("Unable to post", ex.Message));
}
return(null);
}
/// <summary>
/// メッセージを通知する
/// </summary>
/// <param name="message">メッセージ</param>
/// <param name="webhookUrl">webhookUrl</param>
/// <param name="userName">ユーザー名</param>
/// <param name="channelName">チャンネル名(チャンネル名が指定可能なツールのみ対応)</param>
/// <param name="mention">メンションを付けるか(メンションが可能なツールのみ対応)</param>
/// <returns>通知に成功したか</returns>
public async Task <bool> Notify(string message, string webhookUrl, string userName,
string channelName, bool mention = true)
{
// 先頭にChannelメンションを付ける
if (mention)
{
message = $"{ChannelMention}{Environment.NewLine}{message}";
}
// 送信パラメータを作成
var slackPayload = new SlackPayload()
{
text = message,
username = userName,
channel = channelName,
};
// 送信パラメータオブジェクトをJSONに変換
var jsonSlackPayload = JsonConvert.SerializeObject(slackPayload);
// Jsonの送信パラメータ情報をURLに変換
var slackPayloadDictionary = new Dictionary <string, string>()
{
{ PayloadKeyValue, jsonSlackPayload }
};
var urlParameter = new FormUrlEncodedContent(slackPayloadDictionary);
try
{
var response = await _HttpClient.PostAsync(webhookUrl, urlParameter).ConfigureAwait(false);
return(response.StatusCode == HttpStatusCode.OK);
}
catch
{
return(false);
}
}
public async Task PostMessageAsync(string text)
{
SlackPayload payload = new SlackPayload()
{
Channel = _channel,
UserName = _userName,
Text = text,
};
RestResponse restResponse;
try
{
RestContent content = new RestContent(New <IStringSerializer>().Serialize(payload));
restResponse = await Caller.RestAsync(new RestIdentity(), new RestRequest("POST", _accessTokenUrl, TimeSpan.Zero, content)).Free();
ApiCaller.EnsureStatusOk(restResponse);
}
catch (Exception ex)
{
New <IReport>().Exception(ex);
}
}
private async Task SendToSlackAsync(string[] recipients, SlackPayload payload, string format)
{
foreach (var recipient in recipients)
{
payload.Channel = $"{format}{recipient}";
var serializedPayload = JsonConvert.SerializeObject(payload);
using (var httpClient = new HttpClient())
{
var response = await httpClient.PostAsync(_webhookUrl,
new StringContent(serializedPayload, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
_logger.Info($"SLACK | Message to {recipient} has been sent.");
}
else
{
_logger.Info($"SLACK | There were some errors while sending message to {recipient}.");
}
}
}
}
/// <inheritdoc />
public async Task ReportAsync(HealthOptions options, HealthStatus status, CancellationToken cancellationToken = default)
{
var resetRuns = false;
_runs++;
if (!_slackOptions.Enabled || !options.Enabled)
{
Logger.Trace($"Health Status Reporter `{this}` disabled, not reporting.");
return;
}
Logger.Trace($"Health Status Reporter `{this}` reporting health status.");
var applicationName = options.ApplicationName;
if (Uri.TryCreate(applicationName, UriKind.Absolute, out var appUri))
{
applicationName = $"<{appUri}|{appUri}>";
}
var slackMessage = new SlackPayload
{
Text = $"*{applicationName} Unhealthy*",
Channel = _slackOptions.Channel,
UserName = _slackOptions.Username,
IconEmoji = string.IsNullOrWhiteSpace(_slackOptions.EmojiIcon) ? DefaultEmojiIcon : _slackOptions.EmojiIcon
};
var newUnhealthyChecks = status.Results.Where(r => r.Check.Status == HealthCheckStatus.Unhealthy && !LastUnhealthyCheckCache.Contains(r.Name)).ToList();
if (newUnhealthyChecks.Any())
{
AddHealthAttachments(HealthCheckStatus.Unhealthy, newUnhealthyChecks, slackMessage);
}
if (_runs > _slackOptions.RunsBeforeReportExistingFailures)
{
resetRuns = true;
var existingUnHealthyChecks = status.Results
.Where(r => r.Check.Status == HealthCheckStatus.Unhealthy && LastUnhealthyCheckCache.Contains(r.Name) && newUnhealthyChecks.All(c => c.Name != r.Name))
.ToList();
if (existingUnHealthyChecks.Any())
{
AddHealthAttachments(HealthCheckStatus.Unhealthy, existingUnHealthyChecks, slackMessage, reFailure: true);
}
}
if (_slackOptions.AlertOnDegradedChecks)
{
var degradedChecks = status.Results.Where(r => r.Check.Status == HealthCheckStatus.Degraded && !LastDegradedCheckCache.Contains(r.Name)).ToList();
if (degradedChecks.Any())
{
AddHealthAttachments(HealthCheckStatus.Degraded, degradedChecks, slackMessage);
}
if (_runs > _slackOptions.RunsBeforeReportExistingFailures)
{
resetRuns = true;
var existingDegradedChecks = status.Results
.Where(r => r.Check.Status == HealthCheckStatus.Degraded && LastDegradedCheckCache.Contains(r.Name) && degradedChecks.All(c => c.Name != r.Name))
.ToList();
if (existingDegradedChecks.Any())
{
AddHealthAttachments(HealthCheckStatus.Degraded, existingDegradedChecks, slackMessage, reFailure: true);
}
}
}
if (resetRuns)
{
_runs = 0;
}
if (slackMessage.Attachments.Any())
{
try
{
var response = await _httpClient.PostAsync(_slackOptions.WebhookUrl, new JsonContent(slackMessage), cancellationToken);
if (response.IsSuccessStatusCode)
{
Logger.Trace($"Health Status Reporter `{this}` successfully reported health status.");
}
else
{
Logger.Error($"Health Status Reporter `{this}` failed to reported health status with status code: `{response.StatusCode}` and reason phrase: `{response.ReasonPhrase}`");
}
}
catch (Exception ex)
{
Logger.Error(ex, $"Health Status Reporter `{this}` failed to reported health status");
}
}
await AlertStatusChangeChecks(status, applicationName, cancellationToken);
}
