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!");
}
