public void Chirp(string message, params object[] args)
{
if (args.Length > 0)
{
Task.Run(() => _client.PostMessageAsync(
_channel, string.Format(message, args)));
}
else
{
Task.Run(() => _client.PostMessageAsync(
_channel, message));
}
}
public async void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
try
{
string message = $"{categoryName}: {formatter(state, exception)}";
if (exception != null)
{
message = $"{categoryName}: {formatter(state, exception)}\n{exception.GetType().Name}: {exception.Message}\n{exception.StackTrace}";
}
SlackTaskClient slackClient = new SlackTaskClient(slackToken);
var response = await slackClient.PostMessageAsync("errors", message);
if (!response.ok)
{
throw new Exception("Slack communication error.");
}
}
catch (Exception ex)
{
Console.WriteLine($"{DateTime.Now} - ERROR: Failed to send log to slack. ({ex.GetType().FullName}: {ex.Message})");
}
}
public async Task SendMessageToChannel(string channelId, string message)
{
if (channelId == null)
{
throw new ArgumentNullException(nameof(channelId));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
PostMessageResponse response;
try
{
response = await _slackTaskClient.PostMessageAsync(channelId, message);
}
catch (Exception exception)
{
throw new SlackInteractionFailed(exception.Message, DateTimeOffset.Now).ToException();
}
if (!response.ok)
{
throw new SlackInteractionFailed(response.error, DateTimeOffset.Now).ToException();
}
}
private static async Task EnviarMensajeAlBot(string mensaje)
{
const string TOKEN = "xoxb-1078280749793-1064282359525-XpjVVS9IT2btexCd4nYZLC87"; // token from last step in section above
var slackClient = new SlackTaskClient(TOKEN);
var response = await slackClient.PostMessageAsync("#botfalso", mensaje);
}
public async Task Connect()
{
SlackSocketClient.Connect((loginResponse =>
{
if (loginResponse.ok)
{
Logger.LogInformation("Socket client responded ok");
}
else
{
Logger.LogError($"SlackSocketClient Error: {loginResponse.error}");
}
}), () =>
Logger.LogInformation("Socket connected"));
SlackSocketClient.OnMessageReceived += message =>
{
Logger.LogInformation(JsonConvert.SerializeObject(message));
};
SlackSocketClient.OnReactionAdded += reaction =>
{
Logger.LogInformation(JsonConvert.SerializeObject(reaction));
};
await SlackTaskClient.ConnectAsync();
var response = await SlackTaskClient.PostMessageAsync("#sandbox", "Hi", "I'm a bot");
if (!response.ok)
{
Logger.LogError($"Post Message Error: {response.error}");
}
Logger.LogInformation("Connected");
}
public Task SendAsync(Destination destination, BotResponse botResponse, SkypeSender skypeSender = null)
{
if (_isMocked)
{
Console.WriteLine($"{destination.Messenger.ToString()}, {destination.ChannelId}, {destination.UserId}: {botResponse.Text}");
Console.WriteLine("-------------------------------------------------------");
return(Task.CompletedTask);
}
switch (destination.Messenger)
{
case Messenger.Slack:
return(_slackClient.PostMessageAsync(destination.ChannelId, botResponse.Text));
case Messenger.Telegram:
return(_telegramClient != null?_telegramClient.SendTextMessageAsync(destination.ChannelId, botResponse.Text) : Task.CompletedTask);
case Messenger.Skype:
if (skypeSender == null)
{
// todo: log warning: skypeSender is null
return(Task.CompletedTask);
}
return(Task.Run(() => skypeSender.Write(destination.ChannelId, botResponse.Text)));
default:
// todo: log warning: unsupported messenger
return(Task.CompletedTask);
}
}
public async Task Send(string message)
{
SlackTaskClient slackClient = new SlackTaskClient(_provider.AccessCode);
PostMessageResponse response = await slackClient.PostMessageAsync(_provider.ChannelName, message);
Console.WriteLine(response.error);
}
public async Task <IMessageHandle> PostMessageAsync(string channelId, IMessage message)
{
var actualMessage = (SlackMessage)message;
var messageResponse = await _actualClient.PostMessageAsync(
channelId,
actualMessage.Message,
blocks : actualMessage.Blocks
);
if (!messageResponse.ok || !string.IsNullOrEmpty(messageResponse.error))
{
_log.LogError("Failed to send message via Slack [{error}]", messageResponse.error);
throw new InvalidOperationException($"Failed to send message via Slack [{messageResponse.error}]");
}
_log.LogTrace(
$"Sent message via slack [{messageResponse.ts}/${messageResponse.channel}]"
);
var dao = await _slackMessageRepository.Add(new Dao.SlackMessage()
{
Id = Guid.NewGuid(),
ChannelId = messageResponse.channel,
Timestamp = messageResponse.ts,
CreationDateTime = DateTime.Now,
UpdatedDateTime = DateTime.Now
});
await _slackMessageRepository.Save();
return(new MessageHandle(dao.Id));
}
public async Task Test(string msg)
{
const string TOKEN = "TODO-TBD";
var slackClient = new SlackTaskClient(TOKEN);
var response = await slackClient.PostMessageAsync("#general", msg);
}
private async Task SendSlackMessageAsync(string message)
{
var client = new SlackTaskClient(_slackApiToken);
_logger.Log("Sending message '{0}'", message);
var response = await client.PostMessageAsync(_targetChannel, message, linkNames : true, as_user : true);
response.AssertOk();
}
private bool SendToSlack(string message)
{
var token = GetSecret("slack-token");
var client = new SlackTaskClient(token);
var channel = "signup";
var response = client.PostMessageAsync(channel, message);
return(response.Result.ok);
}
// private Task<IEnumerable<Channel>> GetPublicChannels()
// {
// var tsc = new TaskCompletionSource<IEnumerable<Channel>>();
//
// try
// {
// _actualClient.GetChannelList(
// response =>
// {
// if (response.ok)
// {
// tsc.SetResult(new ReadOnlyCollection<Channel>(response.channels));
// }
// else
// {
// tsc.SetException(new InvalidOperationException($"SLACKCLIENT ERROR: {response.error}"));
// }
// }
// );
// }
// catch (Exception e)
// {
// tsc.SetException(e);
// }
//
// return tsc.Task;
// }
//
// private Task<IEnumerable<Channel>> GetPrivateChannels()
// {
// var tsc = new TaskCompletionSource<IEnumerable<Channel>>();
//
// try
// {
// _actualClient.GetGroupsListAsync()
// _actualClient.GetGroupsListAsync(
// response =>
// {
// if (response.ok)
// {
// tsc.SetResult(new ReadOnlyCollection<Channel>(response.groups));
// }
// else
// {
// tsc.SetException(new InvalidOperationException($"SLACKCLIENT ERROR: {response.error}"));
// }
// }
// );
// }
// catch (Exception e)
// {
// tsc.SetException(e);
// }
//
// return tsc.Task;
// }
// private async Task<IEnumerable<Channel>> GetChannels()
// {
// var publicChannels = await GetPublicChannels();
// var privateChannels = await GetPrivateChannels();
//
// return privateChannels.Concat(publicChannels).ToArray();
// }
private async Task <SingleMessageHandle> PostMessageAsync(string channelId, SlackMessage message)
{
var messageResponse = await _actualClient.PostMessageAsync(
channelId,
message.Message,
blocks : message.Blocks
);
_log.LogInformation(
$"RESPONSE >> Received message deliver for [{messageResponse.ts}/${messageResponse.channel}]");
return(new SingleMessageHandle(messageResponse));
}
public async Task <IActionResult> Get()
{
var channel = "general";
var message = "Hello World!";
var response = await _client.PostMessageAsync(channel, message);
var responseMessage = string.Empty;
if (response.ok)
{
responseMessage = "Message sent successfully";
}
else
{
responseMessage = "Message sending failed. error: " + response.error;
}
Console.WriteLine(responseMessage);
return(Ok(new { message = responseMessage }));
}
public async Task <bool> SendToSlack(string channel, string message)
{
try
{
SlackTaskClient slackClient = new SlackTaskClient(configuration["Slack:Token"]);
var response = await slackClient.PostMessageAsync(channel, message);
if (response.ok)
{
return(true);
}
else
{
logger.LogError($"Failed to send notification to slack.");
return(false);
}
}
catch (Exception ex)
{
logger.LogError(ex, $"Failed to send notification to slack. ({ex.GetType().Name}: {ex.Message})");
return(false);
}
}
private async Task sendDM(string whoSent, string message)
{
var token = Environment.GetEnvironmentVariable("SLACK_ACCESS_TOKEN");
if (token == null)
{
throw new Exception("Error getting slack token from ssm");
}
var client = new SlackTaskClient(token);
var response = await client.PostMessageAsync(whoSent, message, null, null, false, null, null, false, null, null, true);
// process response from API call
if (response.ok)
{
Console.WriteLine("Message sent successfully");
}
else
{
Console.WriteLine("Message sending failed. error: " + response.error);
}
}
public async Task PostAsync(MessageToChannel msg)
{
_logger.LogInformation("Posting {Channel} {Message}", msg.ChannelId, msg.Message);
await _client.PostMessageAsync(msg.ChannelId, msg.Message);
}
