Conversas orientadas a eventos usando um manipulador de atividades

Para implementar a lógica para esses manipuladores, você realizará a substituição desses métodos no bot, como na seção de amostra de manipulador de atividades abaixo. Para cada um desses manipuladores, não há uma implementação de base, portanto, basta adicionar a lógica desejada em sua substituição.

Existem determinadas situações em que você desejará realizar a substituição do manipulador de turno de base, como salvar o estado no final de um turno. Ao fazer isso, chame primeiro await base.OnTurnAsync(turnContext, cancellationToken); para fazer com que a implementação base de OnTurnAsync seja executada antes do código adicional. Essa implementação base é, entre outras coisas, responsável por chamar os demais manipuladores de atividade, como OnMessageActivityAsync.

O JavaScript ActivityHandler usa um emissor de eventos e um padrão de ouvinte. Por exemplo, use o método onMessage para registrar um ouvinte de eventos para atividades de mensagem. Você pode registrar mais de um ouvinte. Quando o bot recebe uma atividade de mensagem, o manipulador de atividades vê essa atividade de entrada e a envia a cada um dos ouvintes de atividade onMessage, na ordem em que elas foram registradas.

Ao criar seu bot, a lógica do bot para tratar das mensagens e respondê-las entrará nos ouvintes onMessage. Da mesma forma, a lógica de tratamento de membros que estão sendo adicionados à conversa vai entrar nos ouvintes onMembersAdded, que são chamados sempre que um membro é adicionado à conversa. Para adicionar esses ouvintes, você os registrará em seu bot, conforme visto na seção Lógica do bot abaixo. Para cada ouvinte, inclua a lógica de bot e, em seguida, não se esqueça de chamar next() no final. Ao chamar next(), você garante que o próximo ouvinte seja executado.

Lembre-se de salvar o estado antes que o ciclo seja concluído. Você pode fazer isso substituindo o método run do manipulador de atividade e salvando o estado após a conclusão do método run do pai.

Não existem situações comuns em que você deseje realizar a substituição do manipulador de turno de base, portanto, tenha cuidado ao tentar fazer isso. Existe um manipulador especial chamado onDialog. O manipulador onDialog é executado no final, após a execução do restante dos manipuladores, e não está vinculado a um determinado tipo de atividade. Assim como com todos os manipuladores acima, não deixe de chamar next() para garantir a conclusão do processo.

Para implementar a lógica para esses manipuladores, você realizará a substituição desses métodos no bot, como na seção de amostra de manipulador de atividades abaixo. Não há implementação de base para cada um desses manipuladores, portanto, adicione a lógica desejada em sua substituição.

Existem determinadas situações em que você desejará realizar a substituição do manipulador de turno de base, como salvar o estado no final de um turno. Ao fazer isso, certifique-se primeiro de chamar super.onTurn(turnContext); para garantir que a implementação de base de onTurn seja executada antes do código adicional. Essa implementação base é, entre outras coisas, responsável por chamar os demais manipuladores de atividade, como onMessageActivity.

Ao criar seu bot, sua lógica do bot para tratar das mensagens e respondê-las entrará nesse manipulador on_message_activity. Da mesma forma, sua lógica de tratamento de membros que estão sendo adicionados à conversa vai entrar no manipulador on_members_added, que é chamado sempre que um membro é adicionado à conversa.

Por exemplo, se o bot recebe uma atividade de mensagem, o manipulador de turno vê a atividade de entrada a envia para o manipulador de atividade on_message_activity.

Para implementar a lógica para esses manipuladores, você realizará a substituição desses métodos no bot, como na seção de amostra de manipulador de atividades abaixo. Para cada um desses manipuladores, não há uma implementação de base, portanto, basta adicionar a lógica desejada em sua substituição.

Existem determinadas situações em que você desejará realizar a substituição do manipulador de turno de base, como salvar o estado no final de um turno. Ao fazer isso, chame primeiro await super().on_turn(turnContext); para fazer com que a implementação base de on_turn seja executada antes do código adicional. Essa implementação base é, entre outras coisas, responsável por chamar os demais manipuladores de atividade, como on_message_activity.

A lógica principal do bot é definida no código do bot. Para implementar um bot como um manipulador de atividades, derive a classe de bot de ActivityHandler, que implementa a interface IBot. ActivityHandler define vários manipuladores para diferentes tipos de atividades, como OnMessageActivityAsync e OnMembersAddedAsync. Esses métodos são protegidos, mas podem ser substituídos, já que são derivados de ActivityHandler.

Os manipuladores definidos em ActivityHandler são:

Esses manipuladores diferentes têm um turnContext que fornece informações sobre a atividade de entrada, que corresponde à solicitação HTTP de entrada. As atividades podem ser de vários tipos e, portanto, cada manipulador fornece uma atividade fortemente tipada em seu parâmetro de contexto de turno; na maioria dos casos, OnMessageActivityAsync sempre será manipulado e é geralmente o mais comum.

Como nas versões 4.x anteriores desta estrutura, também existe a opção de implementar o método público OnTurnAsync. Atualmente, a implementação base desse método lida com a verificação de erros e, em seguida, chama cada um dos manipuladores específicos (como os dois que definimos neste exemplo) dependendo do tipo de atividade de entrada. Na maioria dos casos, é possível deixar esse método de lado e usar os manipuladores específicos, mas se a situação exigir uma implementação personalizada de OnTurnAsync, ele ainda será uma opção.

A lógica principal do bot é definida no código do bot. Para implementar um bot como um manipulador de atividades, estenda o ActivityHandler. O ActivityHandler define vários eventos para diferentes tipos de atividades, e é possível modificar o comportamento do seu bot ao registrar ouvintes de eventos, como onMessage e onConversationUpdate.

Use estes métodos para registrar os ouvintes para cada tipo de evento:

Chame a função de continuação next de cada manipulador para permitir que o processamento continue. Se next não for chamado, o processamento da atividade será encerrado.

A lógica principal do bot é definida no código do bot. Para implementar um bot como um manipulador de atividades, derive a classe de bot de ActivityHandler, que implementa a interface Bot. ActivityHandler define vários manipuladores para diferentes tipos de atividades, como onMessageActivity e onMembersAdded. Esses métodos são protegidos, mas podem ser substituídos, já que são derivados de ActivityHandler.

Os manipuladores definidos em ActivityHandler são:

Esses manipuladores diferentes têm um turnContext que fornece informações sobre a atividade de entrada, que corresponde à solicitação HTTP de entrada. As atividades podem ser de vários tipos e, portanto, cada manipulador fornece uma atividade fortemente tipada em seu parâmetro de contexto de turno; na maioria dos casos, onMessageActivity sempre será manipulado e é geralmente o mais comum.

Também existe a opção de implementar o método público onTurn. Atualmente, a implementação base desse método lida com a verificação de erros e, em seguida, chama cada um dos manipuladores específicos (como os dois que definimos neste exemplo) dependendo do tipo de atividade de entrada. Na maioria dos casos, é possível deixar esse método de lado e usar os manipuladores específicos, mas se a situação exigir uma implementação personalizada de onTurn, ele ainda será uma opção.

A lógica principal do bot é definida no código do bot. Para implementar um bot como um manipulador de atividades, derive a classe de bot de ActivityHandler, que, por sua vez, deriva da classe abstrata Bot. ActivityHandler define vários manipuladores para diferentes tipos de atividades, como on_message_activity e on_members_added. Esses métodos são protegidos, mas podem ser substituídos, já que são derivados de ActivityHandler.

Os manipuladores definidos em ActivityHandler são:

Esses manipuladores diferentes têm um turn_context que fornece informações sobre a atividade de entrada, que corresponde à solicitação HTTP de entrada. As atividades podem ser de vários tipos e, portanto, cada manipulador fornece uma atividade fortemente tipada em seu parâmetro de contexto de turno; na maioria dos casos, on_message_activity sempre será manipulado e é geralmente o mais comum.

Como nas versões 4.x anteriores desta estrutura, também existe a opção de implementar o método público on_turn. Atualmente, a implementação base desse método lida com a verificação de erros e, em seguida, chama cada um dos manipuladores específicos (como os dois que definimos neste exemplo) dependendo do tipo de atividade de entrada. Na maioria dos casos, é possível deixar esse método de lado e usar os manipuladores específicos, mas se a situação exigir uma implementação personalizada de on_turn, ele ainda será uma opção.

public class EchoBot : ActivityHandler
{
    protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
    {
        var replyText = $"Echo: {turnContext.Activity.Text}";
        await turnContext.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken);
    }

    protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
    {
        var welcomeText = "Hello and welcome!";
        foreach (var member in membersAdded)
        {
            if (member.Id != turnContext.Activity.Recipient.Id)
            {
                await turnContext.SendActivityAsync(MessageFactory.Text(welcomeText, welcomeText), cancellationToken);
            }
        }
    }
}

const { ActivityHandler, MessageFactory } = require('botbuilder');

class EchoBot extends ActivityHandler {
    constructor() {
        super();
        // See https://aka.ms/about-bot-activity-message to learn more about the message and other activity types.
        this.onMessage(async (context, next) => {
            const replyText = `Echo: ${ context.activity.text }`;
            await context.sendActivity(MessageFactory.text(replyText, replyText));
            // By calling next() you ensure that the next BotHandler is run.
            await next();
        });

        this.onMembersAdded(async (context, next) => {
            const membersAdded = context.activity.membersAdded ?? [];
            const welcomeText = 'Hello and welcome!';
            for (let cnt = 0; cnt < membersAdded.length; ++cnt) {
                if (membersAdded[cnt].id !== context.activity.recipient.id) {
                    await context.sendActivity(MessageFactory.text(welcomeText, welcomeText));
                }
            }
            // By calling next() you ensure that the next BotHandler is run.
            await next();
        });

public class EchoBot extends ActivityHandler {

    @Override
    protected CompletableFuture<Void> onMessageActivity(TurnContext turnContext) {
        return turnContext.sendActivity(
            MessageFactory.text("Echo: " + turnContext.getActivity().getText())
        ).thenApply(sendResult -> null);
    }

    @Override
    protected CompletableFuture<Void> onMembersAdded(
        List<ChannelAccount> membersAdded,
        TurnContext turnContext
    ) {
        String welcomeText = "Hello and welcome!";
        return membersAdded.stream()
            .filter(
                member -> !StringUtils
                    .equals(member.getId(), turnContext.getActivity().getRecipient().getId())
            ).map(channel -> turnContext.sendActivity(MessageFactory.text(welcomeText, welcomeText, null)))
            .collect(CompletableFutures.toFutureList()).thenApply(resourceResponses -> null);
    }
}

class EchoBot(ActivityHandler):
    async def on_members_added_activity(
        self, members_added: [ChannelAccount], turn_context: TurnContext
    ):
        for member in members_added:
            if member.id != turn_context.activity.recipient.id:
                await turn_context.send_activity("Hello and welcome!")

    async def on_message_activity(self, turn_context: TurnContext):
        return await turn_context.send_activity(
            MessageFactory.text(f"Echo: {turn_context.activity.text}")
        )