private async Task <SlackChatHub> GetChatHub(ResponseMessage responseMessage)
{
SlackChatHub chatHub = null;
if (responseMessage.ResponseType == ResponseType.Channel)
{
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
}
else if (responseMessage.ResponseType == ResponseType.DirectMessage)
{
if (string.IsNullOrEmpty(responseMessage.Channel))
{
chatHub = await GetUserChatHub(responseMessage.UserId);
}
else
{
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
}
}
return(chatHub);
}
public async Task <SlackChatHub> GetChatHub(ResponseMessage responseMessage, ISlackConnection connection)
{
SlackChatHub chatHub = null;
if (responseMessage.ChannelType == ChannelType.Channel)
{
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
}
else if (responseMessage.ChannelType == ChannelType.DirectMessage)
{
if (string.IsNullOrEmpty(responseMessage.Channel))
{
chatHub = await this.GetUserChatHub(responseMessage.UserId, connection);
}
else
{
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
}
}
return(chatHub);
}
private async Task should_not_raise_event_given_missing_data(
Mock <IWebSocketClient> webSocket,
SlackConnection slackConnection)
{
// given
var connectionInfo = new ConnectionInformation {
WebSocket = webSocket.Object
};
await slackConnection.Initialise(connectionInfo);
SlackChatHub lastHub = null;
slackConnection.OnChatHubJoined += hub =>
{
lastHub = hub;
return(Task.CompletedTask);
};
var inboundMessage = new ChannelJoinedMessage {
Channel = null
};
// when
webSocket.Raise(x => x.OnMessage += null, null, inboundMessage);
// then
lastHub.ShouldBeNull();
slackConnection.ConnectedHubs.ShouldBeEmpty();
}
private async Task <SlackChatHub> GetChatHub(
IResponseMessage responseMessage,
ISlackConnection slackConnection)
{
SlackChatHub chatHub = null;
switch (responseMessage.ResponseType)
{
case ResponseType.Channel:
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
break;
case ResponseType.DirectMessage when string.IsNullOrEmpty(responseMessage.Channel):
chatHub = await GetUserChatHub(
responseMessage.UserId,
slackConnection);
break;
case ResponseType.DirectMessage:
chatHub = new SlackChatHub {
Id = responseMessage.Channel
};
break;
}
return(chatHub);
}
private async Task should_raise_event(
Mock <IWebSocketClient> webSocket,
SlackConnection slackConnection)
{
// given
var connectionInfo = new ConnectionInformation {
WebSocket = webSocket.Object
};
await slackConnection.Initialise(connectionInfo);
const string hubId = "this-is-the-id";
SlackChatHub lastHub = null;
slackConnection.OnChatHubJoined += hub =>
{
lastHub = hub;
return(Task.CompletedTask);
};
var inboundMessage = new ChannelJoinedMessage
{
Channel = new Channel {
Id = hubId
}
};
// when
webSocket.Raise(x => x.OnMessage += null, null, inboundMessage);
// then
lastHub.Id.ShouldBe(hubId);
lastHub.Type.ShouldBe(SlackChatHubType.Channel);
slackConnection.ConnectedHubs.ContainsKey(hubId).ShouldBeTrue();
slackConnection.ConnectedHubs[hubId].ShouldBe(lastHub);
}
public async Task SendMessage(ResponseMessage responseMessage)
{
SlackChatHub chatHub = await GetChatHub(responseMessage);
if (chatHub != null)
{
if (responseMessage is TypingIndicatorMessage)
{
await _connection.IndicateTyping(chatHub);
}
else
{
var botMessage = new BotMessage
{
ChatHub = chatHub,
Text = responseMessage.Text,
Attachments = GetAttachments(responseMessage.Attachment)
};
await _connection.Say(botMessage);
}
}
else
{
Console.WriteLine("Unable to find channel for message '{0}'. Message not sent", responseMessage.Text);
}
}
public async Task SendMessage(ResponseMessage responseMessage)
{
SlackChatHub chatHub = await GetChatHub(responseMessage);
if (chatHub != null)
{
if (responseMessage is TypingIndicatorMessage)
{
_log.Info($"Indicating typing on channel '{chatHub.Name}'");
await _connection.IndicateTyping(chatHub);
}
else
{
var botMessage = new BotMessage
{
ChatHub = chatHub,
Text = responseMessage.Text,
Attachments = GetAttachments(responseMessage.Attachments)
};
string textTrimmed = botMessage.Text.Length > 50 ? botMessage.Text.Substring(0, 50) + "..." : botMessage.Text;
_log.Info($"Sending message '{textTrimmed}'");
await _connection.Say(botMessage);
}
}
else
{
_log.Error($"Unable to find channel for message '{responseMessage.Text}'. Message not sent");
}
}
private async Task should_upload_file_from_stream(
[Frozen] Mock <IConnectionFactory> connectionFactory,
Mock <IFileClient> fileClient,
Mock <IWebSocketClient> webSocket,
SlackConnection slackConnection)
{
// given
const string slackKey = "key-yay";
const string fileName = "expected-file-name";
var chatHub = new SlackChatHub {
Id = "channelz-id"
};
var stream = new MemoryStream();
var connectionInfo = new ConnectionInformation {
WebSocket = webSocket.Object, SlackKey = slackKey
};
await slackConnection.Initialise(connectionInfo);
connectionFactory
.Setup(x => x.CreateFileClient())
.Returns(fileClient.Object);
// when
await slackConnection.Upload(chatHub, stream, fileName);
// then
fileClient
.Verify(x => x.PostFile(slackKey, chatHub.Id, stream, fileName), Times.Once);
}
async Task INotifyService.Notify(string eventXml, string tfsIdentityXml)
{
if (string.IsNullOrEmpty(eventXml))
{
throw new ArgumentException(nameof(eventXml));
}
var changedItem = new ChangedItem(eventXml);
var link = new SlackAttachment {
Title = changedItem.UrlTitle,
TitleLink = changedItem.Url
};
Console.WriteLine(changedItem.Title + " - " + changedItem.UrlTitle);
var slackHub = new SlackChatHub {
Id = user
};
var policyResult = await Policy
.Handle <Exception>()
.WaitAndRetryAsync(new[] {
TimeSpan.FromSeconds(2),
TimeSpan.FromSeconds(4),
TimeSpan.FromSeconds(8)
})
.ExecuteAndCaptureAsync(
() => slackIntegration.SendMessageToChannel(slackHub, changedItem.Title, link));
if (policyResult.FinalException != null)
{
Console.WriteLine($"Could not post to Slack {policyResult.FinalException}");
}
}
public async void WriteChannel(string command)
{
SlackChatHub channel = connection.ConnectedChannels().Where(x => x.Name == "#general").FirstOrDefault();
var message = new BotMessage();
message.ChatHub = channel;
message.Text = command;
await connection.Say(message);
}
public async Task IndicateTyping(SlackChatHub chatHub)
{
var message = new TypingIndicatorMessage
{
Channel = chatHub.Id
};
await this._webSocketClient.SendMessage(message);
}
public async Task should_send_typing_indicator()
{
// given
SlackChatHub channel = SlackConnection.ConnectedChannel(Config.Slack.TestChannel);
// when
await SlackConnection.IndicateTyping(channel);
// then
}
public void shouldnt_return_slack_hub_if_hub_id_is_null_or_empty(string hubId)
{
// given
// when
var interpreter = new ChatHubInterpreter();
SlackChatHub chatHub = interpreter.FromId(hubId);
// then
chatHub.ShouldBeNull();
}
private void SendWarRoomIncidentChannelMessage(string warRoomChannelName, string messageText)
{
var chatHub = new SlackChatHub {
Id = warRoomChannelName
};
var message = new BotMessage {
ChatHub = chatHub, Text = messageText
};
this.SlackConnection.Say(message);
}
public void then_should_return_expected_slack_hub()
{
var expected = new SlackChatHub
{
Id = ReturnChannel.Id,
Name = ReturnChannel.Name,
Type = SlackChatHubType.DM
};
Result.ShouldLookLike(expected);
}
public void then_should_raised_event_with_expected_channel_information()
{
var expectedChatHub = new SlackChatHub
{
Id = "channel-id",
Name = "@test-user",
Type = SlackChatHubType.DM
};
_lastHub.ShouldLookLike(expectedChatHub);
}
public SlackChatHub GetChatHub(Im im, string user)
{
var dm = new SlackChatHub
{
Id = im.Id,
Name = "@" + (string.IsNullOrEmpty(user) ? im.User : user),
Type = SlackChatHubType.DM
};
return(dm);
}
public SlackChatHub GetChatHub(Channel channel)
{
var newChannel = new SlackChatHub
{
Id = channel.Id,
Name = "#" + channel.Name,
Type = SlackChatHubType.Channel
};
return(newChannel);
}
public static void Say(ReminderNode nextReminder)
{
SlackChatHub H = new SlackChatHub();
H.ID = GetUserDMChannelID(nextReminder.UserName);
BotMessage ConnectionMessage = new BotMessage();
ConnectionMessage.Text = nextReminder.ReminderContent;
ConnectionMessage.ChatHub = H;
Program.memoryBot.Say(ConnectionMessage).Wait();
}
public static SlackChatHub ToChatHub(this Group group)
{
var newGroup = new SlackChatHub
{
Id = group.Id,
Name = "#" + group.Name,
Type = SlackChatHubType.Group,
Members = group.Members
};
return(newGroup);
}
public static SlackChatHub ToChatHub(this Channel channel)
{
var newChannel = new SlackChatHub
{
Id = channel.Id,
Name = "#" + channel.Name,
Type = SlackChatHubType.Channel,
Members = channel.Members
};
return(newChannel);
}
public void shouldnt_return_slack_hub_if_type_cant_be_detected()
{
// given
const string hubId = "SOMETHING THAT ISN'T CORRECT";
// when
var interpreter = new ChatHubInterpreter();
SlackChatHub chatHub = interpreter.FromId(hubId);
// then
chatHub.ShouldBeNull();
}
private async Task <SlackChatHub> GetChatHub(string chatHubid)
{
var infoClient = _connectionFactory.CreateInfoClient();
SlackChatHub result = null;
if (infoClient != null)
{
result = await infoClient.GetChatHub(SlackKey, chatHubid);
}
return(result);
}
public async Task SendFile(SlackChatHub chatHub, string filePath)
{
if (chatHub != null)
{
await _connection.Upload(chatHub, filePath);
_logger.LogInformation($"Sending file '{filePath}'");
}
else
{
_logger.LogError($"Unable to find channel for file '{filePath}'. Message not sent");
}
}
public void should_send_typing_indicator()
{
// given
var config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
var connection = slackConnector.Connect(config.Slack.ApiToken).Result;
SlackChatHub channel = connection.ConnectedChannel(config.Slack.TestChannel);
// when
connection.IndicateTyping(channel).Wait();
// then
}
public void should_send_typing_indicator()
{
// given
var config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
var connection = slackConnector.Connect(config.Slack.ApiToken).Result;
SlackChatHub channel = connection.ConnectedChannels().First(x => x.Name.Equals("#-lobby-", StringComparison.InvariantCultureIgnoreCase));
// when
connection.IndicateTyping(channel).Wait();
// then
}
private async Task RaiseChannelJoined(SlackChatHub chatHub)
{
if (OnChannelJoined != null)
{
try
{
await OnChannelJoined(chatHub);
}
catch (Exception)
{
// ignored
}
}
}
public void should_join_channel()
{
// given
var config = new ConfigReader().GetConfig();
var slackConnector = new SlackConnector();
var connection = slackConnector.Connect(config.Slack.ApiToken).Result;
// when
SlackChatHub result = connection.JoinDirectMessageChannel(config.Slack.TestUserId).Result;
// then
Assert.That(result, Is.Not.Null);
}
private Dictionary <string, SlackChatHub> GetChatHubs(HandshakeResponse handshakeResponse)
{
var hubs = new Dictionary <string, SlackChatHub>();
foreach (Channel channel in handshakeResponse.Channels.Where(x => !x.IsArchived))
{
if (channel.IsMember)
{
var newChannel = new SlackChatHub
{
Id = channel.Id,
Name = "#" + channel.Name,
Type = SlackChatHubType.Channel
};
hubs.Add(channel.Id, newChannel);
}
}
foreach (Group group in handshakeResponse.Groups.Where(x => !x.IsArchived))
{
if (group.Members.Any(x => x == handshakeResponse.Self.Id))
{
var newGroup = new SlackChatHub
{
Id = group.Id,
Name = "#" + group.Name,
Type = SlackChatHubType.Group
};
hubs.Add(group.Id, newGroup);
}
}
foreach (Im im in handshakeResponse.Ims)
{
User user = handshakeResponse.Users.FirstOrDefault(x => x.Id == im.User);
var dm = new SlackChatHub
{
Id = im.Id,
Name = "@" + (user == null ? im.User : user.Name),
Type = SlackChatHubType.DM
};
hubs.Add(im.Id, dm);
}
return(hubs);
}
private async Task RaiseChatHubJoined(SlackChatHub hub)
{
var e = this.OnChatHubJoined;
if (e != null)
{
try
{
await e(hub);
}
catch
{
}
}
}
