public async Task ExecuteEvent(SlackEvent slackEvent)
{
string textToSave = GetEventKeywords(slackEvent.Event.Text);
GetAuthorQueryResult authorResult = await _mediator.Send(new GetAuthorQuery(slackEvent.Event.User));
if (authorResult.Result == QueryResult.NotFound)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.GetCannotSaveMessage("save"),
channel : slackEvent.Event.Channel,
attachment : "");
return;
}
Note note = new Note(
textToSave,
slackEvent.Event.User,
authorResult.Document.Team,
GetUnixTimeNow());
CreateNoteQueryResult result = await _mediator.Send(new CreateNoteQuery(note));
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageNoteSaved,
channel : slackEvent.Event.Channel,
attachment : "");
}
public async Task ExecuteEvent(SlackEvent slackEvent)
{
GetNotesQueryResult results = await _mediator.Send(new GetNotesQuery(slackEvent.Event.User, null, null, GetNotesQueryType.GetUserNotes));
if (results.Result == QueryResult.NotFound)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageNoUserNotesFound,
channel : slackEvent.Event.Channel,
attachment : "");
return;
}
string cacheId = Guid.NewGuid().ToString();
await _mediator.Send(new SetCacheItem(cacheId, results.Documents));
dynamic notesAttachment = _attachmentGenerator.GenerateAttachment(results.Documents, cacheId, 1);
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageUserNotesFound,
channel : slackEvent.Event.Channel,
attachment : (string)notesAttachment);
}
public async Task <IActionResult> Event([FromBody] SlackEvent request)
{
switch (request.Type)
{
case (Constants.Constants.RequestTypeUrlVerification):
return(Ok(_slackVerificationService.VerifySlackEventRequest(request)));
case (Constants.Constants.RequestTypeEventCallback):
if (!_eventFilter.IsBlocked(request))
{
Hangfire.BackgroundJob.Enqueue(() =>
_commandStrategy.ExecuteEvent(request));
}
await _disappearingSlackMessageProvider.SnapSlackMessage(
request.Event.Channel,
request.Event.Ts);
break;
default:
return(Ok());
}
return(Ok());
}
public async Task ExecuteEvent(SlackEvent slackEvent)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageTeamQuestion,
channel : slackEvent.Event.Channel,
attachment : _teamMenuAttachment);
}
public async Task ExecuteEvent(SlackEvent slackEvent)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageFallback,
channel : slackEvent.Event.Channel,
attachment : "");
}
public string VerifySlackEventRequest(SlackEvent challengePayload)
{
if (challengePayload != null && challengePayload.Token == _verificationToken)
{
return(challengePayload.Challenge);
}
return(null);
}
public async Task ExecuteEvent(SlackEvent slackEvent)
{
if (string.IsNullOrWhiteSpace(slackEvent.Event.Text))
{
return;
}
await _commands.FirstOrDefault(x => x.GetEventPattern.IsMatch(slackEvent.Event.Text))?.ExecuteEvent(slackEvent);
}
public async Task ExecuteEvent(SlackEvent slackEvent)
{
string textToSearch = GetEventKeywords(slackEvent.Event.Text);
GetAuthorQueryResult authorResult = await _mediator.Send(new GetAuthorQuery(slackEvent.Event.User));
if (authorResult.Result == QueryResult.NotFound)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.GetCannotSaveMessage("search"),
channel : slackEvent.Event.Channel,
attachment : "");
return;
}
GetNotesQueryResult userNotes = await _mediator.Send(
new GetNotesQuery(
slackEvent.Event.User,
authorResult.Document.Team,
textToSearch,
GetNotesQueryType.SearchUserNotes));
GetNotesQueryResult teamNotes = await _mediator.Send(
new GetNotesQuery(
slackEvent.Event.User,
authorResult.Document.Team,
textToSearch,
GetNotesQueryType.SearchTeamNotes));
if (userNotes.Result == QueryResult.NotFound && teamNotes.Result == QueryResult.NotFound)
{
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageSearchNoNotes,
channel : slackEvent.Event.Channel,
attachment : "");
return;
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(_attachmentGenerator.GenerateAttachment(userNotes.Documents));
stringBuilder.Append(_attachmentGenerator.GenerateAttachment(teamNotes.Documents));
string notesAttachment = stringBuilder.ToString();
await _disappearingSlackMessageProvider.SendDisappearingSlackMessage(
text : Constants.Constants.MessageSearchFoundNotes,
channel : slackEvent.Event.Channel,
attachment : notesAttachment);
}
public ActionResult Event(SlackEvent slackEvent)
{
if (slackEvent.Type == "url_verification")
{
return(Ok(new { challenge = slackEvent.Challenge }));
}
switch (slackEvent.Event.Type)
{
case MessageType:
_eventService.MessageReceived(slackEvent.Event);
return(Ok());
default:
return(Ok());
}
}
public async Task ProcessRequest_EventTypeWrong_Ignore()
{
//Arrange
var slackEvent = new SlackEvent
{
Type = "EmojiReaction"
};
var request = new EventWrapperRequest
{
Event = slackEvent
};
// Act
await _eventService.ProcessRequest(request);
// Assert
_elasticSearchService.VerifyNoOtherCalls();
_slackClientMock.VerifyNoOtherCalls();
}
public async Task ProcessRequest_MessageFromBot_Ignore()
{
//Arrange
var slackEvent = new SlackEvent
{
BotId = "123456"
};
var request = new EventWrapperRequest
{
Event = slackEvent
};
// Act
await _eventService.ProcessRequest(request);
// Assert
_elasticSearchService.VerifyNoOtherCalls();
_slackClientMock.VerifyNoOtherCalls();
}
public async Task ProcessRequest_MessageTextIsEmpty_Ignore()
{
//Arrange
var slackEvent = new SlackEvent
{
Text = string.Empty
};
var request = new EventWrapperRequest
{
Event = slackEvent
};
// Act
await _eventService.ProcessRequest(request);
// Assert
_elasticSearchService.VerifyNoOtherCalls();
_slackClientMock.VerifyNoOtherCalls();
}
public EventServiceTests()
{
var elasticsearchSettingsMock = new Mock <IOptions <ElasticsearchSettings> >();
elasticsearchSettingsMock
.SetupGet(m => m.Value)
.Returns(() => new ElasticsearchSettings());
_elasticSearchService = new Mock <IElasticSearchService>();
_slackClientMock = new Mock <ISlackHttpClient>();
_searchableTextServiceMock = new Mock <ISearchableTextService>();
var logger = new Mock <ILogger <EventService> >();
_eventService = new EventService(_slackClientMock.Object, _elasticSearchService.Object,
_searchableTextServiceMock.Object, logger.Object);
var slackEvent = new SlackEvent
{
Text = "Hello from Slack!",
Channel = "CBGJMA0TA",
UserId = "UBJ6GC75K",
Type = "message"
};
_request = new EventWrapperRequest
{
Event = slackEvent
};
_question = new SearchableQuestion
{
Id = Guid.NewGuid().ToString(),
Text = "???"
};
_answer = new SearchableAnswer()
{
Text = "???",
Id = Guid.NewGuid().ToString(),
QuestionId = Guid.NewGuid().ToString()
};
}
public async Task <ActionResult> Event(SlackEvent slackEvent)
{
if (slackEvent.Type == UrlVerification)
{
return(Ok(new { challenge = slackEvent.Challenge }));
}
switch (slackEvent.Event.Type)
{
case MessageType:
await _eventService.MessageReceived(slackEvent.Event);
return(Ok());
case ReactionAdded:
await _eventService.ReactionAdded(slackEvent.Event);
return(Ok());
default:
return(Ok());
}
}
public string Post([FromBody] SlackEvent json)
{
if (json.token != Configuration.Instance.ChallengeToken)
{
return(null);
}
if (json.challenge != null)
{
return(json.challenge);
}
if (null != json.message && !string.IsNullOrWhiteSpace(json.message.text.Trim()))
{
var text = json.message.text.Trim().ToLowerInvariant();
foreach (var command in Configuration.Instance.Commands)
{
if (null != json.message.user && (text.Contains(command) || intent(text).Contains(command)))
{
var ucmd = new UserCommand
{
user = json.message.user,
command = command,
context = json.message.text.Trim(),
channel = json.message.channel,
event_id = json.event_id,
event_time = json.event_time
};
do
{
try
{
using (var f = System.IO.File.Open(Configuration.Instance.CommandFile, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite, FileShare.None))
{
string fileContent = null;
var sr = new StreamReader(f);
fileContent = sr.ReadToEnd();
if (string.IsNullOrWhiteSpace(fileContent))
{
fileContent = "[]";
}
f.Position = 0;
f.SetLength(0);
f.Flush();
var ucmds = Newtonsoft.Json.JsonConvert.DeserializeObject <List <UserCommand> >(fileContent);
ucmds.Add(ucmd);
var sw = new StreamWriter(f);
sw.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(ucmds));
sw.Flush();
}
break;
}
catch (System.IO.IOException) { }
} while (true);
}
}
}
return("");
}
public bool IsBlocked(SlackEvent slackEvent)
{
return(slackEvent.Event.SubType == "bot_message");
}
/// <summary>
/// Handles all slack messages and calls the specified command handler if it is a command.
/// </summary>
/// <param name="slackEvent"></param>
/// <param name="teamId">The team of the user of the sent request.</param>
/// <returns></returns>
public async Task <IActionResult> HandleSlackMessage(SlackEvent slackEvent, string teamId)
{
if (slackEvent is null || _commandHandler == null)
{
return(BadRequest());
}
// Ignore if the message is coming from the bot
// (The user field is only set on the test server, thus we also need to check for that)
//
if (slackEvent.User == "UJZLBL7BL" || string.IsNullOrEmpty(slackEvent.User))
{
return(Ok());
}
var reply = new Dictionary <string, string>();
var hiddenMessage = false;
//
// Set the reply data
//
reply["channel"] = slackEvent.Channel;
reply["user"] = slackEvent.User;
// We accept two types of messages as command:
// - Normal Chat Messages:
// > time
// > start
// - Bot Mentions
// > @tcslackbot time
// > @tcslackbot start
//
// Slack does not provide names but ids, thus, if we replace the id, it'll basically be treated like a normal chat message and still be handled.
var text = slackEvent.Text.Replace("<@UJZLBL7BL> ", "", StringComparison.CurrentCulture).ToLower().Trim().Split(' ').FirstOrDefault();
//
// Handle the command
//
switch (text)
{
case "login":
case "link":
reply["text"] = _commandHandler.GetLoginLink(slackEvent);
hiddenMessage = true;
break;
case "logout":
case "unlink":
reply["text"] = await _commandHandler.Logout(slackEvent);
break;
case "start":
reply["text"] = await _commandHandler.StartWorkingAsync(slackEvent);
break;
case "stop":
reply["text"] = await _commandHandler.StopWorkingAsync(slackEvent);
break;
case "pause":
case "break":
reply["text"] = await _commandHandler.PauseWorktimeAsync(slackEvent);
break;
case "resume":
reply["text"] = await _commandHandler.ResumeWorktimeAsync(slackEvent);
break;
case "status":
case "time":
reply["text"] = await _commandHandler.GetWorktimeAsync(slackEvent);
break;
case "filter":
reply["text"] = await _commandHandler.FilterObjectsAsync(slackEvent);
break;
case "project":
reply["text"] = await _commandHandler.SetDefaultProject(slackEvent);
break;
default:
break;
}
await SendReplyAsync(teamId, reply, hiddenMessage);
return(Ok());
}
public bool IsBlocked(SlackEvent slackEvent)
{
return(slackEvent.Event.SubType == "message_changed");
}
public bool IsBlocked(SlackEvent slackEvent)
{
return(slackEvent.Event.Channel.StartsWith('G'));
}
public IActionResult PostEvent(SlackEvent e) => Ok(e.Challenge);
public bool IsBlocked(SlackEvent slackEvent)
{
return(_filters.Any(x => x.IsBlocked(slackEvent)));
}
