public async Task Handle(BlockActionRequest request, Responder respond)
{
if (request.Action.ActionId == _actionId)
{
await _handler.Handle(request, respond).ConfigureAwait(false);
}
}
public async Task Handle(TAction action, BlockActionRequest request)
{
if (request.Action.ActionId == _actionId)
{
await _handler.Handle(action, request).ConfigureAwait(false);
}
}
public async Task Handle(ExternalSelectAction select, BlockActionRequest request)
{
await _slack.Chat.PostMessage(new Message
{
Text = $"Selected color: {select.SelectedOption.Text.Text} ({select.SelectedOption.Value})",
Channel = request.Channel.Id
}).ConfigureAwait(false);
}
public async Task Handle(ButtonAction button, BlockActionRequest request)
{
var counter = SectionBeforeAddButtons(button, request);
if (counter != null)
{
var counterText = _counterPattern.Match(counter.Text.Text ?? string.Empty);
if (counterText.Success)
{
var count = int.Parse(counterText.Groups[1].Value);
var increment = int.Parse(((ButtonAction)request.Action).Value);
counter.Text = $"Counter: {count + increment}";
await _slack.Chat.Update(new MessageUpdate
{
Ts = request.Message.Ts,
Text = request.Message.Text,
Blocks = request.Message.Blocks,
Attachments = request.Message.Attachments,
ChannelId = request.Channel.Id
}).ConfigureAwait(false);
}
}
}
private async Task <HttpResponse> HandleBlockActions(HttpContext context, BlockActionRequest blockActionRequest)
{
await _slackBlockActions.Handle(blockActionRequest).ConfigureAwait(false);
return(await context.Respond(HttpStatusCode.OK).ConfigureAwait(false));
}
public Task Handle(BlockActionRequest request, Responder respond) => ResolvedHandle(h => h.Handle(request, respond));
private Task <SlackResult> HandleBlockActions(BlockActionRequest blockActionRequest) => RespondAsync(r => _blockActionHandler.Handle(blockActionRequest, r));
public void RegisterBlockActionHandler()
{
// Arrange
var keyedHandler = Substitute.For <IBlockActionHandler <ButtonAction> >();
var typedHandler = Substitute.For <IBlockActionHandler <ButtonAction> >();
var genericHandler = Substitute.For <IBlockActionHandler>();
var keyedAsyncHandler = Substitute.For <IAsyncBlockActionHandler <ButtonAction> >();
var typedAsyncHandler = Substitute.For <IAsyncBlockActionHandler <ButtonAction> >();
var genericAsyncHandler = Substitute.For <IAsyncBlockActionHandler>();
var overflowRequest = new BlockActionRequest {
Actions = { new OverflowAction {
ActionId = "other"
} }
};
var otherButtonAction = new ButtonAction {
ActionId = "other"
};
var otherButtonRequest = new BlockActionRequest {
Actions = { otherButtonAction }
};
var buttonAction = new ButtonAction {
ActionId = "key"
};
var buttonRequest = new BlockActionRequest {
Actions = { buttonAction }
};
var responder = Substitute.For <Responder>();
var sut = Configure(c => c
.RegisterBlockActionHandler("key", keyedHandler)
.RegisterBlockActionHandler(typedHandler)
.RegisterBlockActionHandler(genericHandler)
.RegisterAsyncBlockActionHandler("key", keyedAsyncHandler)
.RegisterAsyncBlockActionHandler(typedAsyncHandler)
.RegisterAsyncBlockActionHandler(genericAsyncHandler));
// Act
HandleBlockActions(sut, responder, new[] { overflowRequest, otherButtonRequest, buttonRequest });
// Assert
keyedHandler.DidNotReceive().Handle(Arg.Any <ButtonAction>(), overflowRequest);
keyedHandler.DidNotReceive().Handle(otherButtonAction, otherButtonRequest);
keyedHandler.Received().Handle(buttonAction, buttonRequest);
typedHandler.DidNotReceive().Handle(Arg.Any <ButtonAction>(), overflowRequest);
typedHandler.Received().Handle(otherButtonAction, otherButtonRequest);
typedHandler.Received().Handle(buttonAction, buttonRequest);
genericHandler.Received().Handle(overflowRequest);
genericHandler.Received().Handle(otherButtonRequest);
genericHandler.Received().Handle(buttonRequest);
keyedAsyncHandler.DidNotReceive().Handle(Arg.Any <ButtonAction>(), overflowRequest, responder);
keyedAsyncHandler.DidNotReceive().Handle(otherButtonAction, otherButtonRequest, responder);
keyedAsyncHandler.Received().Handle(buttonAction, buttonRequest, responder);
typedAsyncHandler.DidNotReceive().Handle(Arg.Any <ButtonAction>(), overflowRequest, responder);
typedAsyncHandler.Received().Handle(otherButtonAction, otherButtonRequest, responder);
typedAsyncHandler.Received().Handle(buttonAction, buttonRequest, responder);
genericAsyncHandler.Received().Handle(overflowRequest, responder);
genericAsyncHandler.Received().Handle(otherButtonRequest, responder);
genericAsyncHandler.Received().Handle(buttonRequest, responder);
}
public Task Handle(BlockActionRequest request) => _slackBlockActions.Handle(request);
private async Task <SlackResponse> HandleBlockActions(BlockActionRequest blockActionRequest)
{
await _slackBlockActions.Handle(blockActionRequest).ConfigureAwait(false);
return(new EmptyResponse(HttpStatusCode.OK));
}
public async Task Handle(ButtonAction action, BlockActionRequest request)
{
await OpenDialog(action.ActionId, request.TriggerId).ConfigureAwait(false);
}
public async Task Handle(ButtonAction action, BlockActionRequest request, Responder respond)
{
}
public async Task Handle(ButtonAction action, BlockActionRequest request)
{
}
public async Task Handle(BlockActionRequest request)
{
}
private static SectionBlock SectionBeforeAddButtons(ButtonAction button, BlockActionRequest request)
{
return(request.Message.Blocks
.TakeWhile(b => b.BlockId != button.BlockId)
.LastOrDefault() as SectionBlock);
}
