/// <summary>
/// Connects to slack and starts listening for the phrase specified in the settings.
/// </summary>
public async Task Run()
{
var connector = new SlackConnector.SlackConnector();
try
{
connection = await connector.Connect(settings.AccessToken);
}
catch (CommunicationException)
{
throw new ShushBotException("Unable to connect to slack workspace using the provided access token. Ensure that it is correct.");
}
Console.WriteLine("Connected to slack.");
var channels = await connection.GetChannels();
var matchingChannel = channels.FirstOrDefault(x => x.Name == settings.Channel);
channel = matchingChannel ?? throw new ShushBotException($"Unable to find a channel with the name {settings.Channel}");
connection.OnMessageReceived += MessageReceived;
Console.WriteLine($"Connected to channel {settings.Channel}");
Console.WriteLine($"Listening to messages. If a user PMs me '{settings.Keyword}', I will respond with:\n{settings.Phrase}");
if (settings.UseImages)
{
Console.WriteLine("I will also display an image provided in images.json.");
}
while (true)
{
}
}
public async Task <ISlackConnection> GetConnection()
{
var connector = new SlackConnector.SlackConnector();
var connection = await connector.Connect(this.configuration.SlackApiKey);
return(connection);
}
public async void TestE2E()
{
var slackConnector = new SlackConnector.SlackConnector();
var restClient = new RestClient();
var envReader = new EnvironmentVariableReader();
var secretHandler = new SecretHandler();
var app = new App(restClient, envReader, slackConnector, secretHandler);
await app.Run();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var connector = new SlackConnector.SlackConnector();
var slackAccessToken = _attribute.SlackAccessToken;
_connection = await connector.Connect(slackAccessToken);
_connection.OnMessageReceived += ConnectionOnOnMessageReceived;
_connection.OnDisconnect += ConnectionOnOnDisconnect;
}
public async Task <bool> Connect()
{
_log.Debug("Connecting to Slack.");
var connector = new SlackConnector.SlackConnector();
_connection = await connector.Connect(_config.Token);
_connection.OnMessageReceived += ReceiveMessage;
_connection.OnDisconnect += HandleDisconnect;
return(true);
}
public SlackIntegration(ILogger logger, IConfig config)
{
_logger = logger;
_config = config;
//Config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector.SlackConnector();
SlackConnection = Task.Run(() => slackConnector.Connect(_config.Slack.ApiToken))
.GetAwaiter()
.GetResult();
}
public void Start()
{
this.mainIncidentChannel = this.configReader.GetConfigEntry <string>("incident:mainChannel");
this.PostmortemTemplateLink = this.configReader.GetConfigEntry <string>("incident:postmortemTemplateLink");
this.WarRooms = this.configReader.GetConfigEntry <string>("incident:warRooms").Split(',');
var connector = new SlackConnector.SlackConnector();
this.SlackConnection = connector.Connect(this.configReader.SlackApiKey).Result;
this.log.Info("(IncidentModule) started up.");
}
public void should_connect_and_stuff()
{
// given
var slackConnector = new SlackConnector.SlackConnector();
// when
var connection = slackConnector.Connect(_config.Slack.ApiToken).Result;
connection.OnDisconnect += SlackConnector_OnDisconnect;
connection.OnMessageReceived += SlackConnectorOnOnMessageReceived;
// then
Assert.That(connection.IsConnected, Is.True);
}
public void should_connect_and_stuff()
{
// given
var slackConnector = new SlackConnector.SlackConnector();
// when
var connection = slackConnector.Connect(_config.Slack.ApiToken).Result;
connection.OnDisconnect += SlackConnector_OnDisconnect;
connection.OnMessageReceived += SlackConnectorOnOnMessageReceived;
// then
Assert.That(connection.IsConnected, Is.True);
}
public void WaitingForConnection()
{
Receive <ISlackConnection>(connection =>
{
Become(() => Connected(connection));
Stash.UnstashAll();
});
ReceiveAny(_ => Stash.Stash());
var slackConfiguration = new Slack();
var connector = new SlackConnector.SlackConnector();
connector.Connect(slackConfiguration.Token).PipeTo(Self);
}
public async Task Connect()
{
JObject config = _configReader.GetConfig();
string slackKey = config["slack"].Value <string>("apiToken");
var connector = new SlackConnector.SlackConnector();
_connection = await connector.Connect(slackKey);
_connection.OnMessageReceived += MessageReceived;
_connection.OnDisconnect += OnDisconnect;
Console.WriteLine("Connected!");
Console.WriteLine($"Bots Name: {_connection.Self.Name}");
Console.WriteLine($"Team Name: {_connection.Team.Name}");
}
private void PublishMessageSync(ISlackMessage slackMessage)
{
var slackConnector = new SlackConnector.SlackConnector();
var connection = slackConnector.Connect(slackMessage.Token).Result;
var message = new BotMessage
{
Text = slackMessage.Text,
ChatHub =
connection.ConnectedChannels()
.First(
x =>
x.Name.Equals("#" + slackMessage.Channel.Trim('#'),
StringComparison.InvariantCultureIgnoreCase))
};
connection.Say(message).Wait();
}
public async Task ConnectAsync()
{
string slackKey = _options.ApiKey;
var connector = new SlackConnector.SlackConnector();
_connection = await connector.Connect(slackKey);
_connection.OnMessageReceived += MessageReceived;
_connection.OnDisconnect += OnDisconnect;
_connection.OnReconnecting += OnReconnecting;
_connection.OnReconnect += OnReconnect;
_logger.LogInformation("Connected!");
_logger.LogInformation($"Bots Name: {_connection.Self.Name}");
_logger.LogInformation($"Team Name: {_connection.Team.Name}");
}
public void should_say_something_on_channel()
{
// given
var slackConnector = new SlackConnector.SlackConnector();
var connection = slackConnector.Connect(_config.Slack.ApiToken).Result;
var message = new BotMessage
{
Text = "Test text from SlackConnectorTests :)",
ChatHub = connection.ConnectedChannels().First(x => x.Name.Equals("#general", StringComparison.InvariantCultureIgnoreCase))
};
// when
connection.Say(message).Wait();
// then
}
private void PublishMessageSync(ISlackMessage slackMessage)
{
var slackConnector = new SlackConnector.SlackConnector();
var connection = slackConnector.Connect(slackMessage.Token).Result;
var message = new BotMessage
{
Text = slackMessage.Text,
ChatHub =
connection.ConnectedChannels()
.First(
x =>
x.Name.Equals("#" + slackMessage.Channel.Trim('#'),
StringComparison.InvariantCultureIgnoreCase))
};
connection.Say(message).Wait();
}
public void should_say_something_on_channel()
{
// given
var slackConnector = new SlackConnector.SlackConnector();
var connection = slackConnector.Connect(_config.Slack.ApiToken).Result;
var message = new BotMessage
{
Text = "Test text from SlackConnectorTests :)",
ChatHub = connection.ConnectedChannels().First(x => x.Name.Equals("#general", StringComparison.InvariantCultureIgnoreCase))
};
// when
connection.Say(message).Wait();
// then
}
public SlackBot(ISlackBotCommand[] commands, ISlackConfiguration configuration, IShutdown shutdown)
{
if (!configuration.Enabled)
{
return;
}
CancellationToken token = shutdown.Token;
Worker = Task.Run(() =>
{
SlackConnector.SlackConnector connector = new SlackConnector.SlackConnector();
ISlackConnection client = connector.Connect(configuration.BotUserToken).Result;
client.OnMessageReceived += message =>
{
var context = new SlackBotCommandContext(client.Say, message);
var tasks = new List <Task>();
Parallel.ForEach(commands, command =>
{
Task task;
if (command.TryHandle(context, token, out task))
{
tasks.Add(task);
}
});
// TODO: Implement various messages - randomly selected
// - also implement a "/help" command type
if (tasks.Count == 0)
{
return(context.WriteText("Hey, you're cool, but I don't understand what you're trying to do."));
}
return(Task.WhenAll(tasks));
};
token.WaitHandle.WaitOne();
client.Disconnect();
}, token);
}
public async Task Connect()
{
string slackKey = _configReader.SlackApiKey();
var connector = new SlackConnector.SlackConnector();
_connection = await connector.Connect(slackKey);
_connection.OnMessageReceived += MessageReceived;
_connection.OnDisconnect += OnDisconnect;
_log.Info("Connected!");
_log.Info($"Bots Name: {_connection.Self.Name}");
_log.Info($"Team Name: {_connection.Team.Name}");
_container.GetPlugin<StatsPlugin>()?.RecordStat("Connected:Since", DateTime.Now.ToString("G"));
_container.GetPlugin<StatsPlugin>()?.RecordStat("Response:Average", _averageResponse);
StartPlugins();
}
public async Task Connect()
{
string slackKey = _configReader.SlackApiKey();
var connector = new SlackConnector.SlackConnector();
_connection = await connector.Connect(slackKey);
_connection.OnMessageReceived += MessageReceived;
_connection.OnDisconnect += OnDisconnect;
_log.Info("Connected!");
_log.Info($"Bots Name: {_connection.Self.Name}");
_log.Info($"Team Name: {_connection.Team.Name}");
_container.GetPlugin <StatsPlugin>()?.RecordStat("Connected:Since", DateTime.Now.ToString("G"));
_container.GetPlugin <StatsPlugin>()?.RecordStat("Response:Average", _averageResponse);
StartPlugins();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var connector = new SlackConnector.SlackConnector();
ISlackConnection conn = await connector.Connect(_config.SlackToken);
conn.OnMessageReceived += message => Task.Run(async() => {
using (var scope = _serviceProvider.CreateScope()) {
var botRequest = new BotRequest {
Messenger = Messenger.Slack,
ChannelId = message.ChatHub.Id,
UserId = message.User.Id,
IsDirectMessage = message.ChatHub.Type == SlackConnector.Models.SlackChatHubType.DM,
Text = message.Text,
};
MessageHandler messageHandler = scope.ServiceProvider.GetService <MessageHandler>();
await messageHandler.HandleRequestAsync(botRequest);
}
}, cancellationToken);
}
public void PublishMessage(ISlackMessage slackMessage)
{
if (string.IsNullOrWhiteSpace(slackMessage.Token)
|| string.IsNullOrWhiteSpace(slackMessage.Channel)
|| string.IsNullOrWhiteSpace(slackMessage.Username)
|| string.IsNullOrWhiteSpace(slackMessage.Text))
return;
var slackConnector = new SlackConnector.SlackConnector();
var connection = slackConnector.Connect(slackMessage.Token).Result;
var message = new BotMessage
{
Text = slackMessage.Text,
ChatHub =
connection.ConnectedChannels()
.First(
x => x.Name.Equals("#" + slackMessage.Channel.Trim('#'), StringComparison.InvariantCultureIgnoreCase))
};
// when
connection.Say(message).Wait();
}
private async Task ConnectToSlack()
{
try
{
var slackConnector = new SlackConnector.SlackConnector();
_slackConnection = await slackConnector.Connect(_config.Slack.BotUserToken);
_slackConnection.OnMessageReceived += MessageReceived;
_slackConnection.OnDisconnect += OnDisconnect;
_slackConnection.OnReconnecting += OnReconnecting;
_slackConnection.OnReconnect += OnReconnect;
_logger.Information("Connected!");
_logger.Verbose($"Team Name: {_slackConnection.Team.Name}");
_logger.Verbose($"Bots Name: {_slackConnection.Self.Name}");
}
catch (System.Exception e)
{
_logger.Error(e, e.Message);
throw;
}
}
public SlackProvider()
{
this.client = new SlackConnector.SlackConnector();
}
public SlackProvider()
{
this.client = new SlackConnector.SlackConnector();
}
