protected IntegrationTest()
{
Config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
SlackConnection = Task.Run(() => slackConnector.Connect(Config.Slack.ApiToken))
.GetAwaiter()
.GetResult();
}
public override async Task StartAsync()
{
Connection = await Client.Connect(_key);
Connection.OnMessageReceived += async message =>
{
await OnMessageReceive.Invoke(new SlackMessageObject(message));
};
await base.StartAsync();
}
async Task ICommandHandler.Initialize(ISlackConnection connection)
{
_connection = connection;
_connection.OnMessageReceived += MessageReceived;
_commandService.AddModules(Assembly.GetEntryAssembly());
_commandService.CommandErrored += CommandServiceOnCommandErrored;
await Task.CompletedTask;
}
public void Disconnect()
{
if (null == _connection)
{
return;
}
_connection.Disconnect();
_connection = null;
}
public async Task StartAsync(CancellationToken cancellationToken)
{
connector = new SlackConnector.SlackConnector();
var accessToken = AmbientConnectionStringProvider.Instance.GetConnectionString(attribute.AccessToken);
connection = await connector.Connect(accessToken);
connection.OnMessageReceived += ConnectionOnOnMessageReceived;
connection.OnDisconnect += ConnectionOnOnDisconnect;
}
public void SetUp()
{
_filePath = Path.GetTempFileName();
File.WriteAllText(_filePath, EmbeddedResourceFileReader.ReadEmbeddedFileAsText("UploadTest.txt"));
_config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
_slackConnection = slackConnector.Connect(_config.Slack.ApiToken).Result;
}
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 Connect()
{
this.connection = await this.connectionFactory.GetConnection();
this.connection.OnMessageReceived += this.MessageReceived;
this.connection.OnDisconnect += this.OnDisconnect;
this.connection.OnReconnecting += this.OnReconnecting;
this.connection.OnReconnect += this.OnReconnect;
this.log.LogInformation($"Connected to {this.connection.Team.Name} as @{this.connection.Self.Name}!");
}
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 async Task ConnectAsync()
{
var botAccessToken = _configuration.SlackBotUserToken;
_connection = await _serviceProvider.GetRequiredService <SlackConnector.SlackConnector>()
.Connect(botAccessToken);
var commandHandler = _serviceProvider.GetRequiredService <ICommandHandler>();
await commandHandler.Initialize(_connection);
Console.WriteLine("Connected");
Console.WriteLine("----------------");
Console.WriteLine($"Bot Name: {_connection.Self.Name}");
Console.WriteLine($"Team Name: {_connection.Team.Name}");
}
public void should_connect_and_stuff()
{
// given
var config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
// when
_slackConnection = slackConnector.Connect(config.Slack.ApiToken).Result;
_slackConnection.OnDisconnect += SlackConnector_OnDisconnect;
_slackConnection.OnMessageReceived += SlackConnectorOnMessageReceived;
// then
Assert.That(_slackConnection.IsConnected, Is.True);
}
public Task Execute(ITriggerArguments arguments, ISlackConnection connection, SlackChatHub chatHub, SlackerContext context)
{
if (arguments == null || arguments.Arguments.Length != 1)
{
connection.Say(new BotMessage
{
ChatHub = chatHub,
Text = "Usage: !talk <user>"
});
return(Task.CompletedTask);
}
var user = arguments.Arguments[0];
var messages = context.Messages.Where(x => x.User == user && x.Content.Length > 10);
if (!messages.Any())
{
connection.Say(new BotMessage
{
ChatHub = chatHub,
Text = $"There aren't enough messages by {arguments.Arguments[0]} to go on"
});
return(Task.CompletedTask);
}
var chain = new MarkovChain <string>(1);
foreach (var message in messages)
{
chain.Add(message.Content.Split(new[] { ' ' }), 1);
}
var random = new Random(DateTime.UtcNow.Millisecond);
var stringBuilder = new StringBuilder(GetRandomMessageStart(user, random));
stringBuilder.Append(">" + string.Join(" ", chain.Chain(random)));
connection.Say(new BotMessage
{
ChatHub = chatHub,
Text = stringBuilder.ToString()
});
return(Task.CompletedTask);
}
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}");
}
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}");
}
private async Task <SlackChatHub> GetUserChatHub(string userId, ISlackConnection connection, bool joinChannel = true)
{
SlackChatHub chatHub = null;
if (connection.UserCache.ContainsKey(userId))
{
var username = "******" + connection.UserCache[userId].Name;
chatHub = connection.ConnectedDMs().FirstOrDefault(x => x.Name.Equals(username, StringComparison.OrdinalIgnoreCase));
}
if (chatHub == null && joinChannel)
{
chatHub = await connection.JoinDirectMessageChannel(userId);
}
return(chatHub);
}
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 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 Start()
{
try
{
_connection = _slackBot.Connect(_slackToken).Result;
if (!_firstStart)
{
return;
}
_connection.OnMessageReceived += OnMessageReceivedEventHandler;
_connection.OnDisconnect += OnDisconnectEventHandler;
_firstStart = false;
}
catch (Exception ex)
{
OnErrorEventHandler(this, ex, "An error occurred while trying to connect.");
}
}
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 = this._configReader.SlackApiKey;
var connector = new SlackConnector.SlackConnector();
this._connection = await connector.Connect(slackKey);
this._connection.OnMessageReceived += this.MessageReceived;
this._connection.OnDisconnect += this.OnDisconnect;
this._connection.OnReconnecting += this.OnReconnecting;
this._connection.OnReconnect += this.OnReconnect;
this._logger.LogInformation("Connected!");
this._logger.LogInformation($"Bots Name: {this._connection.Self.Name}");
this._logger.LogInformation($"Team Name: {this._connection.Team.Name}");
this._container.GetPlugin <StatsPlugin>()?.RecordStat("Connected:Since", DateTime.Now.ToString("G"));
this._container.GetPlugin <StatsPlugin>()?.RecordStat("Response:Average", this._averageResponse);
this.StartPlugins();
}
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;
}
}
private async Task ProcessResponder(
IResponder responder,
IncomingMessage message,
ISlackConnection slackConnection,
ILogger log)
{
foreach (var handler in responder.Handlers)
{
var messageText = message.FullText;
if (handler.MessageShouldTargetBot)
{
messageText = message.TargetedText;
}
await ProcessHandles(
message,
handler,
messageText,
slackConnection,
log);
}
}
private async Task SendMessage(
IResponseMessage responseMessage,
ISlackConnection slackConnection,
ILogger log)
{
var chatHub = await GetChatHub(responseMessage, slackConnection);
if (chatHub == null)
{
throw new ArgumentNullException(nameof(chatHub));
}
if (responseMessage is TypingIndicatorMessage)
{
await slackConnection.IndicateTyping(chatHub);
return;
}
if (!(responseMessage is ResponseMessage message))
{
throw new Exception("Unknown message type");
}
var botMessage = new BotMessage
{
ChatHub = chatHub,
Text = message.Text,
Attachments = GetAttachments(message.Attachments)
};
var textTrimmed = botMessage.Text.Length > 50
? botMessage.Text.Substring(0, 50) + "..."
: botMessage.Text;
log.LogInformation($"Sending message '{textTrimmed}'");
await slackConnection.Say(botMessage);
}
public async Task<bool> Connect()
{
ServicePointManager.ServerCertificateValidationCallback +=
(sender, certificate, chain, policyErrors) => { return true; };
try
{
Disconnect();
_log.Info("Slackbot:Connecting");
if (_connection != null && _connection.IsConnected) return true;
_connection = await _connector.Connect(_apiToken);
_connection.OnMessageReceived += MessageReceived;
_connection.OnDisconnect += ConnectionStatusChanged;
_log.Info("Slackbot:Connected");
_isConnected = true;
return true;
}
catch (Exception e)
{
_log.Error("Error connecting to slackbot:" + e.Message, e);
}
return false;
}
private async Task ProcessHandles(
IncomingMessage message,
HandlerMapping handler,
string messageText,
ISlackConnection slackConnection,
ILogger log)
{
foreach (var handle in handler.ValidHandles)
{
if (!handle.IsMatch(messageText))
{
continue;
}
await foreach (var responseMessage in handler.EvaluatorFunc(message, handle))
{
await SendMessage(
responseMessage,
slackConnection,
log);
}
}
}
private void Reconnect()
{
this.log.LogInformation("Reconnecting...");
if (this.connection != null)
{
this.connection.OnMessageReceived -= this.MessageReceived;
this.connection.OnDisconnect -= this.OnDisconnect;
this.connection = null;
}
this.Connect()
.ContinueWith(task =>
{
if (task.IsCompleted && !task.IsCanceled && !task.IsFaulted)
{
this.log.LogInformation("Connection restored.");
}
else
{
this.log.LogError($"Error while reconnecting. Ex: {task.Exception}");
}
});
}
protected override void When()
{
Result = SUT.Connect(SlackKey).Result;
}
internal void Reconnect()
{
_log.Info("Reconnecting...");
if (_connection != null)
{
_connection.OnMessageReceived -= MessageReceived;
_connection.OnDisconnect -= OnDisconnect;
_connection = null;
}
_isDisconnecting = false;
Connect()
.ContinueWith(task =>
{
if (task.IsCompleted && !task.IsCanceled && !task.IsFaulted)
{
_log.Info("Connection restored.");
_container.GetPlugin<StatsPlugin>().IncrementState("ConnectionsRestored");
}
else
{
_log.Info($"Error while reconnecting: {task.Exception}");
}
});
}
public async void Connect()
{
// we don't have to join channels - just choose the channel when sending the message
connection = await client.Connect(Config.SlackToken);
connection.OnMessageReceived += Connection_OnMessageReceived;
}
public static IEnumerable <SlackChatHub> ConnectedGroups(this ISlackConnection slackConnection)
{
return(slackConnection.ConnectedHubs.Values.Where(hub => hub.Type == SlackChatHubType.Group));
}
/// <summary>
/// Will try and find a channel the bot is connected to with that name, e.g. #group
/// </summary>
public static SlackChatHub ConnectedGroup(this ISlackConnection slackConnection, string groupName)
{
return(slackConnection.ConnectedGroups().FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase)));
}
public void SetSlackConnection(ISlackConnection connection)
{
_connection = connection;
_wait.Set();
}
public static IEnumerable <SlackChatHub> ConnectedDMs(this ISlackConnection slackConnection)
{
return(slackConnection.HubCache.Values.Where(hub => hub.Type == SlackChatHubType.DM));
}
private void Disconnect()
{
if (_connection != null)
{
_connection.OnMessageReceived -= MessageReceived;
_connection.OnDisconnect -= ConnectionStatusChanged;
_connection.Disconnect();
_connection = null;
}
}
