public Task <ResultInfo> SendMessageAsync(CreateHelpRequest message, string appName = null)
{
return(RetryUtils.DoAsync(async() =>
{
var text = new StringBuilder();
if (!string.IsNullOrEmpty(appName))
{
text.AppendLine($"*AppName:* {appName}");
}
text.AppendLine($"*From:* {message.Email}");
text.AppendLine($"*Subject:* {message.Subject}");
text.AppendLine($"*Description:* {message.Description}");
var slack = new SlackClient(_options.Url);
var slackMessage = new SlackMessage()
{
Channel = _options.Channel,
Text = text.ToString(),
Username = _options.Username,
IconEmoji = Emoji.Angel
};
return await slack.PostAsync(slackMessage) ? new ResultInfo(HttpStatusCode.OK) : new ResultInfo(HttpStatusCode.BadRequest, "Error in post message");
},
TimeSpan.FromMilliseconds(500),
3,
false,
exception => { LoggerUtils.Log("SlackManager exception", exception, nameof(SlackManager)); }));
}
public async Task <ActionResult> FlagUrl([FromQuery] string url)
{
var message = $"Please flag url: {url}";
if (!string.IsNullOrEmpty(url))
{
try {
var slackClient = new SlackClient(_chatSettings.SlackWebhookUrl);
var slackMessage = new SlackMessage {
Channel = "#userrequests",
Text = $"{message}\n\nFrom: {_applicationUser.GetBestGuessName()}\nFromId: {_applicationUser.Id}\nFromEmail: {_applicationUser.Email}",
IconEmoji = Emoji.HearNoEvil,
Username = _applicationUser.Slug
};
await slackClient.PostAsync(slackMessage);
} catch (Exception e) {
_logger.LogError("Error posting user flag url to slack");
_logger.LogError(e.Message);
}
var request = new UserRequest()
{
RequestText = message,
FromUser = _applicationUser
};
_userRequestRepository.AddOrUpdate(request);
await _unitOfWork.CompleteAsync();
return(Ok());
}
return(BadRequest());
}
public async Task SendMessageAsync(Article article)
{
if (_isSlackEnabled)
{
var slack = new SlackClient(_slackChanelUrl);
await slack.PostAsync(new SlackMessage()
{
Channel = _slackChanel,
Text = article.ArticleType.ToString(),
Username = "******",
Attachments = new List <SlackAttachment>()
{
new SlackAttachment()
{
Title = article.Title,
TitleLink = article.Link,
Color = "warning",
Pretext = article.ShortText
}
}
});
_log.Info("Message to Slack sent for article: " + article.Title);
article.IsSent = true;
}
}
private async Task SendMessage(string url, string msg)
{
var client = new SlackClient(url);
await client.PostAsync(new SlackMessage()
{
Username = "******",
IconEmoji = ":ghost:",
Text = msg
});
}
public async Task SendMessage(string message, string icon, string username)
{
var slackClient = new SlackClient(_webhookUrl);
await slackClient.PostAsync(new SlackMessage
{
Text = message,
IconEmoji = icon,
Username = username
});
}
public static async Task <bool> SendToSlackAsync(this System.Exception ex, ExtraInfo extraInfo = null)
{
try
{
var slackMessage = GetExceptionText(ex, extraInfo);
return(await SlackClient.PostAsync(slackMessage).ConfigureAwait(false));
}
catch (System.Exception e)
{
throw e;
}
}
public async Task <bool> PostMessageAsync(string message, string iconName)
{
var iconEmoji = _config.Icons.FirstOrDefault(x => x.Name == iconName)?.EmojiName;
var slackMessage = new SlackMessage()
{
Channel = _config.Channel, IconEmoji = iconEmoji, Username = _config.Username, Text = message
};
var result = await _client.PostAsync(slackMessage);
return((int)result.StatusCode < 400 && String.IsNullOrEmpty(result.ErrorMessage));
}
public async Task SendNotification(string title, string message, Dictionary <string, string> facts = null, string color = null)
{
if (!configuration.Enabled)
{
return;
}
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var blocks = new List <Block>();
blocks.Add(new Section
{
Text = new TextObject($"*{title}*")
{
Type = TextObject.TextType.Markdown
},
Fields = new List <TextObject>
{
new TextObject {
Text = message
}
}
});
if (facts != null)
{
var factMarkDown = string.Join("\n", facts.Select(t => $"> *{t.Key}* : {t.Value}"));
blocks.Add(new Section
{
Text = new TextObject(factMarkDown)
{
Type = TextObject.TextType.Markdown
}
});
}
var slackMessage = new SlackMessage
{
IconEmoji = Emoji.Ghost,
Username = "******",
Text = title,
Blocks = blocks
};
var slackClient = new SlackClient(configuration.Webhook);
await slackClient.PostAsync(slackMessage);
}
/// <summary>
/// Post message to Slack
/// Slackにポストする
/// </summary>
/// <param name="webHookUrl"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task <string> PostSlack(string webHookUrl, string message)
{
var client = new SlackClient(webHookUrl);
var slackMessage = new SlackMessage
{
Channel = "#sigfox_test",
Text = message,
IconEmoji = Emoji.RobotFace,
Username = "******"
};
await client.PostAsync(slackMessage);
return("Send message detail: " + message);
}
/// <summary>
/// Overrides <see cref="PeriodicBatchingSink.EmitBatchAsync"/> and sends the <see cref="LogEvent"/> with a <see cref="SlackClient"/> to Slack.
/// </summary>
/// <param name="events">A collection of <see cref="LogEvent"/>.</param>
/// <returns>An Awaitable Task.</returns>
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
// check activation status
if (_slackSinkActivationSwitch.SlackSinkStatus == SlackSinkActivationSwitch.SlackSinkActivationStatus.InActive)
{
return;
}
foreach (LogEvent logEvent in events)
{
// create new slack message
var msg = new SlackMessage
{
Attachments = _generateSlackMessageAttachments(logEvent, _formatProvider, _slackSinkOptions),
Blocks = _generateSlackMessageBlocks(logEvent, _formatProvider, _slackSinkOptions),
Channel = _slackSinkOptions.SlackChannels != null && _slackSinkOptions.SlackChannels.Any() ? _slackSinkOptions.SlackChannels[0] : null,
DeleteOriginal = _slackSinkOptions.SlackDeleteOriginal,
IconEmoji = _slackSinkOptions.SlackEmojiIcon,
IconUrl = _slackSinkOptions.SlackUriIcon,
LinkNames = _slackSinkOptions.SlackLinkNames,
Markdown = _slackSinkOptions.SlackMarkdown,
Parse = _slackSinkOptions.SlackParse,
ReplaceOriginal = _slackSinkOptions.SlackReplaceOriginal,
ResponseType = _slackSinkOptions.SlackResponseType,
Text = _generateSlackMessageText(logEvent, _formatProvider, _slackSinkOptions),
ThreadId = _slackSinkOptions.SlackThreadId,
Username = _slackSinkOptions.SlackUsername
};
// check for multi channel post
if (_slackSinkOptions.SlackChannels != null)
{
// multi channel post
var logMsgPosts = _slackClient.PostToChannelsAsync(msg, _slackSinkOptions.SlackChannels);
foreach (Task <bool> logMsgPost in logMsgPosts)
{
await logMsgPost;
}
}
else
{
// single channel post
await _slackClient.PostAsync(msg);
}
}
}
public async Task <bool> NotifyUser(ChatViewModel message)
{
if (string.IsNullOrEmpty(_chatSettings.SlackWebhookUrl))
{
return(false);
}
var slackClient = new SlackClient(_chatSettings.SlackWebhookUrl);
var slackMessage = new SlackMessage {
Channel = _chatSettings.SlackChannel,
Text = $"{message.Message}\n\nFrom: {message.FromUserName}\nFromId: {message.FromUserId}",
IconEmoji = Emoji.HearNoEvil,
Username = message.FromUserName
};
return(await slackClient.PostAsync(slackMessage));
}
protected void SendMessageWithWebHooks(string webhookUri, string message)
{
SelfLog.WriteLine("Trying to send message to webhook '{0}': '{1}'.", webhookUri, message);
if (!string.IsNullOrWhiteSpace(message))
{
var slackClient = new SlackClient(webhookUri, 25);
var sendMessageTask = slackClient.PostAsync(message);
Task.WaitAll(sendMessageTask);
var sendMessageResult = sendMessageTask.Result;
if (sendMessageResult != null)
{
SelfLog.WriteLine("Message sent to webhook '{0}': '{1}'.", webhookUri, sendMessageResult.StatusCode);
}
}
}
public async Task NotifyAsync(string webhookUrl, IEnumerable <string> messages)
{
var client = new SlackClient(webhookUrl);
var postMessage = new List <string>
{
"```"
};
postMessage.AddRange(messages);
postMessage.Add("```");
var slackMessage = new SlackMessage()
{
Text = string.Join("\r\n", postMessage),
};
_ = await client.PostAsync(slackMessage);
}
public async Task <bool> SendSlackMessageAsync(string message, string channel, string userName, string icon)
{
var uri = await new SimpleSystemsManagementService()
.GetParameterValueAsync(GetEnvironmentVariableValue("SLACK_URI"));
var slackClient = new SlackClient(uri);
if (!Enum.TryParse <Emoji>(icon, out Emoji emoji))
{
emoji = Emoji.RobotFace;
}
var slackMessage = new SlackMessage
{
Channel = channel,
Text = message,
IconEmoji = emoji,
Username = userName
};
return(await slackClient.PostAsync(slackMessage));
}
private static async Task Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("settings.json", false)
.AddUserSecrets(Assembly.GetEntryAssembly())
.Build();
var queues = configuration.GetSection("Queues").Get <List <string> >();
var messageCounts = queues.ToDictionary(q => q, _ => (uint)0);
var connectionFactory = CreateConnectionFactory(configuration);
var cts = new CancellationTokenSource();
var runningTask = Task.Run(async() =>
{
using var connection = connectionFactory.CreateConnection();
using var channel = connection.CreateModel();
foreach (var q in queues)
{
messageCounts[q] = channel.MessageCount(q);
}
while (!cts.IsCancellationRequested)
{
foreach (var queueName in queues)
{
var count = channel.MessageCount(queueName);
Log($"Queue {queueName} contains {count} messages.");
messageCounts.TryGetValue(queueName, out var oldCount);
if (count > oldCount)
{
Log($"{queueName} contains {count - oldCount} more message(s) than before.");
if (IsSlackConfigured())
{
await SendWebHookAsync(queueName, oldCount, count);
}
}
messageCounts[queueName] = count;
}
await Task.Delay(TimeSpan.FromMinutes(1), cts.Token);
}
}, cts.Token);
Log("Monitoring RabbitMQ. Hit return to stop.");
Console.ReadLine();
cts.Cancel();
try
{
await runningTask;
}
catch (OperationCanceledException)
{
}
async Task SendWebHookAsync(string queueName, uint oldCount, uint newCount)
{
var slackClient = new SlackClient(configuration["Slack:WebHookEndPoint"]);
var channelName = configuration["Slack:ChannelName"];
Log($"-- Sending message to channel {channelName}..");
await slackClient.PostAsync(new SlackMessage
{
Channel = channelName,
Text = $"Queue {queueName} contains {newCount} messages, up from {oldCount}.",
IconEmoji = Emoji.Ghost
});
}
bool IsSlackConfigured() => !string.IsNullOrWhiteSpace(configuration["Slack:WebHookEndPoint"]) &&
!string.IsNullOrWhiteSpace(configuration["Slack:ChannelName"]);
public AquariumMonitor(Store store, IHubContext <DashboardHub> hubContext, IConfiguration configuration)
{
this._store = store;
this._hubContext = hubContext;
this._aquaWebHookUrl = configuration.GetSection("WebHookUrl").GetSection("AquariumSlack").Get <string>();
this._errorWebHookUrl = configuration.GetSection("WebHookUrl").GetSection("ErrorSlack").Get <string>();
var slackClient = new SlackClient(this._aquaWebHookUrl).AddTo(this._compositeDisposable);
var errorSlackClient = new SlackClient(this._errorWebHookUrl).AddTo(this._compositeDisposable);
// 更新値通知
this._store
.Aquarium
.LatestTimeStamp
.CombineLatest(
this._store.Aquarium.LatestWaterTemperature,
this._store.Aquarium.LatestHumidity,
this._store.Aquarium.LatestTemperature,
(time, water, humidity, temp) => new { time, water, humidity, temp })
.Throttle(TimeSpan.FromMilliseconds(10))
.Subscribe(async x => {
await this._hubContext.Clients.All.SendAsync(
DashboardHub.GetMethodName(DashboardHub.Method.AquaStateChanged),
x.time,
x.water,
x.humidity,
x.temp);
}).AddTo(this._compositeDisposable);
// 室温警告
store
.Aquarium
.LatestTemperature
.Where(x => x >= 30 && x >= this._store.Aquarium.LastWarnedTemperature.Value + 0.5)
.Subscribe(async x => {
this._store.Aquarium.LastWarnedTemperature.Value = x;
await slackClient.PostAsync(new SlackMessage {
Text = $"室温警告 : {x:##.000}℃", Username = "******"
});
}).AddTo(this._compositeDisposable);
// 室温警告解除
store
.Aquarium
.LatestTemperature
.Where(_ => this._store.Aquarium.LastWarnedTemperature.Value >= 29)
.Where(x => x < 29 || x <= this._store.Aquarium.LastWarnedTemperature.Value - 0.5)
.Subscribe(async x => {
this._store.Aquarium.LastWarnedTemperature.Value = x;
if (x < 29)
{
await slackClient.PostAsync(new SlackMessage {
Text = $"室温警告解除 : {x:##.000}℃", Username = "******"
});
}
else
{
await slackClient.PostAsync(new SlackMessage {
Text = $"室温が{x:##.000}℃まで下がりました。", Username = "******"
});
}
}).AddTo(this._compositeDisposable);
// 水温警告
store
.Aquarium
.LatestWaterTemperature
.Where(x => x >= 29 && x >= this._store.Aquarium.LastWarnedWaterTemperature.Value + 0.5)
.Subscribe(async x => {
this._store.Aquarium.LastWarnedWaterTemperature.Value = x;
await slackClient.PostAsync(new SlackMessage {
Text = $"水温警告 : {x:##.000}℃", Username = "******"
});
}).AddTo(this._compositeDisposable);
// 水温警告解除
store
.Aquarium
.LatestWaterTemperature
.Where(_ => this._store.Aquarium.LastWarnedWaterTemperature.Value >= 28)
.Where(x => x < 28 || x <= this._store.Aquarium.LastWarnedWaterTemperature.Value - 0.5)
.Subscribe(async x => {
this._store.Aquarium.LastWarnedWaterTemperature.Value = x;
if (x < 28)
{
await slackClient.PostAsync(new SlackMessage {
Text = $"水温警告解除 : {x:##.000}℃", Username = "******"
});
}
else
{
await slackClient.PostAsync(new SlackMessage {
Text = $"水温が{x:##.000}℃まで下がりました。", Username = "******"
});
}
}).AddTo(this._compositeDisposable);
store.Aquarium
.LatestWaterTemperature
.Throttle(TimeSpan.FromMinutes(10))
.Subscribe(async _ => {
await errorSlackClient.PostAsync(new SlackMessage {
Text = "10分間水温を受信していません。"
});
});
}
