Conversas orientadas a eventos usando um manipulador de atividades

Para implementar a sua lógica para estes gestores, irá substituir esses métodos no seu bot, como na secção de manipulador de atividades de exemplo abaixo. Para cada um desses manipuladores, não existe uma implementação base, então basta adicionar a lógica desejada na sua substituição.

Há certas situações em que se desejará substituir o manipulador de turno base, como salvar o estado no final de um turno. Ao fazer isso, certifique-se de primeiro chamar await base.OnTurnAsync(turnContext, cancellationToken); para garantir que a implementação base de OnTurnAsync seja executada antes do seu código adicional. Essa implementação base é, entre outras coisas, responsável por chamar os outros manipuladores de atividade, como OnMessageActivityAsync.

O JavaScript ActivityHandler usa um emissor de eventos e um padrão de listener. Por exemplo, use o método onMessage para registar um ouvinte de eventos para atividades de mensagem. Você pode registrar mais de um ouvinte. Quando o bot recebe uma atividade de mensagem, o gestor de atividades deteta essa atividade de entrada e envia-a para cada um dos ouvintes de onMessage atividade, pela ordem em que foram registados.

Ao criar o seu bot, a lógica do seu bot para lidar e responder a mensagens irá para os onMessage escutadores. Da mesma forma, sua lógica para lidar com membros que estão sendo adicionados à conversa irá para seus onMembersAdded ouvintes, que são chamados sempre que um membro é adicionado à conversa. Para adicionar estes ouvintes, irá registá-los no seu bot, conforme visto na secção Lógica do bot abaixo. Para cada ouvinte, inclua a lógica do bot e, em seguida, certifique-se de chamar next() no final. Ao chamar next(), você garante que o próximo listener seja executado.

Certifique-se de guardar o estado antes que o turno termine. Você pode fazer isso substituindo o método de manipulador de atividades run e salvando o estado após a conclusão do método pai run.

Não há situações comuns em que se queira substituir o controlador de turno base, portanto tenha cuidado se tentar fazê-lo. Há um manipulador especial chamado onDialog. O onDialog manipulador é executado no final, depois que o restante dos manipuladores é executado, e não está vinculado a um determinado tipo de atividade. Como acontece com todos os manipuladores acima, certifique-se de chamar next() para garantir que o resto do processo seja concluído.

Para implementar a sua lógica para estes gestores, irá substituir esses métodos no seu bot, como na secção de manipulador de atividades de exemplo abaixo. Não há implementação base para cada um desses manipuladores, portanto, adicione a lógica desejada ao substituir.

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

Ao criar o seu bot, a lógica do seu bot para lidar e responder a mensagens irá para este on_message_activity manipulador. Da mesma forma, a sua lógica para lidar com membros que são adicionados à conversa vai para o seu on_members_added manipulador de eventos, que é chamado sempre que um membro é adicionado à conversa.

Por exemplo, se o bot receber uma atividade de mensagem, o gestor de turnos verá a atividade de entrada e enviá-la-á para o on_message_activity manipulador de atividades.

Para implementar a sua lógica para estes gestores, irá substituir esses métodos no seu bot, como na secção de manipulador de atividades de exemplo abaixo. Para cada um desses manipuladores, não existe uma implementação base, então basta adicionar a lógica desejada na sua substituição.

Há certas situações em que se desejará substituir o manipulador de turno base, como salvar o estado no final de um turno. Ao fazer isso, certifique-se de primeiro chamar await super().on_turn(turnContext); para garantir que a implementação base de on_turn seja executada antes do seu código adicional. Essa implementação base é, entre outras coisas, responsável por chamar os outros 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 sua classe de bot de ActivityHandler, que implementa a IBot interface. 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, uma vez que estamos derivando 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, de modo que cada manipulador fornece uma atividade fortemente tipada no seu parâmetro de contexto de turno; na maioria dos casos, OnMessageActivityAsync será sempre tratado, sendo esta geralmente a mais comum.

Como nas versões 4.x anteriores desta estrutura, há também a opção de implementar o método OnTurnAsyncpúblico . 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, você pode deixar esse método sozinho e usar os manipuladores individuais, mas se sua situação exigir uma implementação personalizada do OnTurnAsync, ainda é 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 ActivityHandler. ActivityHandler define vários eventos para diferentes tipos de atividades e você pode modificar o comportamento do bot registrando ouvintes de eventos, como com onMessage e onConversationUpdate.

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

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

A lógica principal do bot é definida no código do bot. Para implementar um bot como um manipulador de atividades, derive sua classe de bot de ActivityHandler, que implementa a Bot interface. 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, uma vez que estamos derivando 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, de modo que cada manipulador fornece uma atividade fortemente tipada no seu parâmetro de contexto de turno; na maioria dos casos, onMessageActivity será sempre tratado, sendo esta geralmente a mais comum.

Há também a opção de implementar o método onTurnpúblico. 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, você pode deixar esse método sozinho e usar os manipuladores individuais, mas se sua situação exigir uma implementação personalizada do onTurn, ainda é 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 sua 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, uma vez que estamos derivando 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, de modo que cada manipulador fornece uma atividade fortemente tipada no seu parâmetro de contexto de turno; na maioria dos casos, on_message_activity será sempre tratado, sendo esta geralmente a mais comum.

Como nas versões 4.x anteriores desta estrutura, há também a opção de implementar o método on_turnpúblico . 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, você pode deixar esse método sozinho e usar os manipuladores individuais, mas se sua situação exigir uma implementação personalizada do on_turn, ainda é 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}")
        )