public virtual T InterpretMessage(SlashCommandPayload payload) { Guard.ThrowIfNull(payload.text); var splitText = SplitTextToParts(payload.text); if (payload.text.StartsWith(option.ToString().ToLower())) { splitText.First().IsUsed = true; } if (IsHelpRequest(splitText.Where(x => !x.IsUsed))) { return(new T { IsHelp = true }); } var message = new T { Date = ExtractDate(splitText), UserId = payload.user_id, UserName = payload.user_name }; ExtractInto(message, splitText); if (splitText.Any(x => !x.IsUsed)) { message.ErrorMessage = $"Not sure how to interpret '{splitText.Where(x => !x.IsUsed).Select(x => x.Text).Join(" ")}'"; } return(message); }
public async Task <IActionResult> DelayedResponsePost() { var streamHelper = new StreamHelper(); var requestBody = streamHelper.ReadAsString(Request.Body).Result; var slashCommandPayload = new SlashCommandPayload(requestBody); // Verify Slack request signature if (!SignatureValidationService.SignatureValid(Request.Headers["X-Slack-Signature"], Request.Headers["X-Slack-Request-Timestamp"], requestBody, SlackSettings.SignatureSecret)) { return(BadRequest()); } // Queue background task var exampleDelayedWorkService = new ExampleDelayedWorkService(new SlackDelayedResponseService()); BackgroundJob.Enqueue(() => exampleDelayedWorkService.DoWork(slashCommandPayload)); // Return an immediate response to Slack while the backgroundjob is still processing var slashCommandResponse = new SlashCommandResponse() { ResponseType = "ephemeral", Text = "Processing your request." }; return(Ok(slashCommandResponse)); }
public IMessageOrchestration Create(SlashCommandPayload payload) { switch (payload.ReadOption()) { case SlackMessageOptions.Web: return(new WebMessageOrchestration(dbContext, webAppUri)); case SlackMessageOptions.Record: return(new RecordMessageOrchestration(dbContext)); case SlackMessageOptions.Delete: return(new DeleteMessageOrchestration(dbContext)); case SlackMessageOptions.Summary: return(new ReportMessageOrchestration(dbContext)); case SlackMessageOptions.Projects: return(new ProjectsMessageOrchestration(dbContext)); case SlackMessageOptions.Help: return(new HelpMessageOrchestration()); default: return(new HelpMessageOrchestration()); } }
/// <summary> /// Takes in a slash command, processes it based on the message text, acts on the database and then returns /// a response message for the user. /// </summary> /// <param name="slashCommandPayload"></param> /// <returns></returns> public Task <SlackMessage> HandleCommand(SlashCommandPayload slashCommandPayload) { Guard.ThrowIfNull(slashCommandPayload); var orchestration = messageOrchestrationFactory.Create(slashCommandPayload); return(orchestration.GenerateResponse(slashCommandPayload)); }
public string GetByRank([FromQuery] SlashCommandPayload payload) { //string rank = payload.text; //var user = _context.ScoreboardsItems.Where(u => u.Rank == rank); //return user.First().Name return("Working"); }
public IHttpActionResult Post(SlashCommandPayload request) { Task.Run(async() => { _nowProcessor.Process(request); }); return(Ok()); }
// Used for testing public async Task <IActionResult> Get() { var payload = new SlashCommandPayload() { Text = "start Demo-Server", }; if (CommandExecutionService.IsCommandValid(payload.Text)) { BackgroundJob.Enqueue(() => CommandExecutionService.Execute(payload)); } return(Ok()); }
public void DoWork(SlashCommandPayload slashCommandPayload) { // Do stuff here // Build Slack response model var responseModel = new SlashCommandResponse() { ResponseType = "in_channel", Text = "It's 80 degrees right now." }; // Send delayed response to Slack SlackDelayedResponseService.SendDelayedResponse(slashCommandPayload.ResponseUrl, responseModel); }
public void Process(SlashCommandPayload command) { var character = new NowCharacter(); var reply = new SlashCommandReply(); var action = GetAction(command.text); switch (action) { case NowActions.Checkin: reply.text = GenerateCheckin(); reply.response_type = "in_channel"; break; case NowActions.CreateCharacter: character = GetCharacter(command.team_domain, command.user_name); reply.text = String.Format("Behold {0}, a powerful {1} (Level {2}).\nStr: {3}, Dex: {4}, Con: {5}, Int: {6}, Wis: {7}, Cha: {8}", character.Name, character.Class, character.Level, character.Strength, character.Dexterity, character.Constitution, character.Intelligence, character.Wisdom, character.Charisma); reply.response_type = "in_channel"; break; case NowActions.RerollCharacter: character = RerollCharacter(command.team_domain, command.user_name); reply.text = String.Format("{0} has rerolled {1} and returned to level {2}.\nStr: {3}, Dex: {4}, Con: {5}, Int: {6}, Wis: {7}, Cha: {8}", character.Name, character.Class, character.Level, character.Strength, character.Dexterity, character.Constitution, character.Intelligence, character.Wisdom, character.Charisma); reply.response_type = "in_channel"; break; case NowActions.Help: reply.text = "/rpg..... Create or show off your character\n/rpg reroll..... Reset your character, class, stats and level\n/rpg leaderboard..... List top 10 characters on your server\n/rpg fight {name}..... Fight your character against {name}\n/rpg help..... Show this list of commands"; reply.response_type = "ephemeral"; break; case NowActions.Leaderboard: reply.text = GetLeaderboard(command.team_domain); reply.response_type = "ephemeral"; break; case NowActions.Fight: character = GetCharacter(command.team_domain, command.user_name); reply.text = Fight(command.team_domain, character.Name, command.text); reply.response_type = reply.text == "Opponent not found." ? "ephemeral" : "in_channel"; break; case NowActions.Error: default: reply.text = "Error in command string."; reply.response_type = "ephemeral"; break; } SendPost(reply, command.response_url); }
public override HoursInterpretedMessage InterpretMessage(SlashCommandPayload payload) { var prefixes = new Dictionary <string, string> { { "/sick", "sick" }, { "/vacation", "vacation" }, { "/nonbill", "nonbill" } }; if (!string.IsNullOrEmpty(payload.command) && prefixes.ContainsKey(payload.command)) { payload.text = $"{prefixes[payload.command]} {payload.text}"; } return(base.InterpretMessage(payload)); }
public Task <SlackMessage> GenerateResponse(SlashCommandPayload payload) { var sb = new StringBuilder(); sb.AppendLine("*/hours* record - Allows the user to record hours."); sb.AppendLine("*/hours* summary - Shows the users reported hours."); sb.AppendLine("*/hours* delete - Deletes hours reported."); sb.AppendLine("*/hours* projects - Lists available projects (project - client)."); sb.AppendLine("*/hours* web - Links user to web for hours report."); sb.AppendLine("Add 'help' to each one of the options to get specific help. ex: */hours* record help"); return(Task.FromResult(new SlackMessage { Text = sb.ToString() })); }
public override ActionResult <object> HandleCommand([FromForm] SlashCommandPayload payload) { List <Release> activeReleases = ReleaseService.GetActiveReleases(); Release activeRelease = activeReleases.FirstOrDefault(); // Status if (string.IsNullOrWhiteSpace(payload.text) || payload.text.ToLower().Contains("status")) { return(ResponseService.PreprodStatus(activeReleases)); } // Take if (payload.text.ToLower().Contains("take")) { if (activeRelease != null) { return(ResponseService.PreprodStatus(activeReleases)); } else { ReleaseService.CreateRelease(new Release(payload.user_name, payload.text)); return(ResponseService.PreprodTaken()); } } // Done if (payload.text.ToLower().Contains("done")) { List <Release> currentUserReleases = activeReleases.Where(m => m.User == payload.user_name).ToList(); if (currentUserReleases == null) { return("There is no active release in your name, idiot"); } else { foreach (var release in currentUserReleases) { release.Ended = DateTime.Now; ReleaseService.UpdateRelease(release); } return(ResponseService.PreprodReleased()); } } return(string.Format($"'{payload.text}' is not a recognised command, supported commands are 'status', 'take' or 'done'")); }
public void Execute(SlashCommandPayload slashCommandPayload) { // Parse the command var slackCommand = CommandParseService.ParseCommand(slashCommandPayload.Text); // Find the right command to execute var command = VirtualMachineCommandFactory.GetCommand(slackCommand); // Execute command command.Execute(); // Send response to slack var responseModel = new SlashCommandResponse() { ResponseType = "in_channel", Text = command.GetResultMessage() }; SlackDelayedResponseService.SendDelayedResponse(slashCommandPayload.ResponseUrl, responseModel); }
public void ParseFromFormEncodedData_returnsCorrectValuesFromFormData() { var data = "token=gIkuvaNzQIHg97ATvDxqgjtO&team_id=T0001" + "&team_domain=example&enterprise_id=E0001" + "&enterprise_name=Globular%20Construct%20Inc" + "&channel_id=C2147483705&channel_name=test" + "&user_id=U2147483697" + "&user_name=Steve" + "&command=/weather" + $"&text={WebUtility.UrlEncode("report acme 8 yesterday")}" + $"&response_url={WebUtility.UrlEncode("https://hooks.slack.com/commands/1234/5678")}" + "&trigger_id=13345224609.738474920.8088930838d88f008e0"; var typedCommandPayload = SlashCommandPayload.ParseFromFormEncodedData(data); typedCommandPayload.text.Should().Be("report acme 8 yesterday"); typedCommandPayload.response_url.Should().Be("https://hooks.slack.com/commands/1234/5678"); }
public static async Task <IActionResult> RunHttpTrigger( [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest request, ILogger logger, ExecutionContext context) { logger.LogInformation($"C# Http trigger function processed message: {request}"); SetupConfiguration(context); SetupServiceCollection(); var slackResponder = new SlackMessageResponder(logger); string responseUrl = null; // todo: play with dc scope / disposing try { var requestBody = await new StreamReader(request.Body).ReadToEndAsync(); var typedMessage = SlashCommandPayload.ParseFromFormEncodedData(requestBody); responseUrl = typedMessage.response_url; var orchestrator = serviceProvider.GetService <SlackMessageOrchestrator>(); var responseMessage = await orchestrator.HandleCommand(typedMessage); await slackResponder.SendMessage(typedMessage.response_url, responseMessage); } catch (Exception exc) { logger.LogError(exc.Message); if (responseUrl != null) { await slackResponder.SendMessage(responseUrl, new SlackMessage() { Text = $"*Error:* _{exc.Message}_\n Source: {exc.Source} \n {exc.StackTrace}" }); } return(new BadRequestObjectResult(exc.Message)); } return(new OkResult()); }
public async Task <IActionResult> Post() { var streamHelper = new StreamHelper(); var requestBody = streamHelper.ReadAsString(Request.Body).Result; var slashCommandPayload = new SlashCommandPayload(requestBody); // Verify request signature if (!SignatureValidationService.SignatureValid(Request.Headers["X-Slack-Signature"], Request.Headers["X-Slack-Request-Timestamp"], requestBody, SlackSettings.SignatureSecret)) { return(BadRequest()); } // Validate command and return error to Slack if the command is invalid if (!CommandExecutionService.IsCommandValid(slashCommandPayload.Text)) { // No command was found to execute this request, send error response to Slack var slashCommandErrorResponse = new SlashCommandResponse() { ResponseType = "ephemeral", Text = "Sorry, we were unable to understand your request. Please try again or type /help for more information." }; // Even though an error occured, Slack needs a 200 OK response code (see Slack docs) return(Ok(slashCommandErrorResponse)); } BackgroundJob.Enqueue(() => CommandExecutionService.Execute(slashCommandPayload)); //CommandExecutionService.Execute(slashCommandPayload); // Send response to Slack var slashCommandResponse = new SlashCommandResponse() { ResponseType = "in_channel", Text = "Executing Command" }; return(Ok(slashCommandResponse)); }
public async Task <SlackMessage> GenerateResponse(SlashCommandPayload payload) { var interpreter = new TInterpreter(); var interpretMessage = interpreter.InterpretMessage(payload); if (interpretMessage.HasError) { return(new SlackMessage { Text = $"Error: *{interpretMessage.ErrorMessage}*" }); } if (interpretMessage.IsHelp) { return(new SlackMessage { Text = interpreter.HelpMessage }); } return((await RespondTo(interpretMessage)).ToMessage()); }
public async Task <IActionResult> ImmediateResponsePost() { var streamHelper = new StreamHelper(); var requestBody = streamHelper.ReadAsString(Request.Body).Result; var slashCommandPayload = new SlashCommandPayload(requestBody); // Verify Slack request signature if (!SignatureValidationService.SignatureValid(Request.Headers["X-Slack-Signature"], Request.Headers["X-Slack-Request-Timestamp"], requestBody, SlackSettings.SignatureSecret)) { return(BadRequest()); } // Do stuff here // Return an immediate response to slack var slashCommandErrorResponse = new SlashCommandResponse() { ResponseType = "in_channel", Text = "It's 80 degrees right now." }; return(Ok(slashCommandErrorResponse)); }
public async Task <ActionResult <SlackMessage> > HandleCommand([FromForm] SlashCommandPayload slashCommandPayload) { var message = await messageOrchestrator.HandleCommand(slashCommandPayload); return(Ok(message)); }
public virtual ActionResult <object> HandleCommand([FromForm] SlashCommandPayload payload) { return("Slash command received!"); }