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); }