Conversations basées sur les événements à l'aide d'un gestionnaire d'activités

Pour implémenter votre logique pour ces gestionnaires, vous allez remplacer ces méthodes dans votre bot, comme dans l'exemple de gestionnaire d'activité ci-dessous. Comme aucun de ces gestionnaires ne dispose d'une implémentation de base, ajoutez simplement la logique que vous voulez dans votre remplacement.

Il peut arriver que vous souhaitiez remplacer le gestionnaire de tours standard, comme l'enregistrement de l'état à la fin d'un tour. Lors de cette opération, veillez à appeler en premier await base.OnTurnAsync(turnContext, cancellationToken); pour vous assurer que l’implémentation de base de OnTurnAsync est exécutée avant votre code supplémentaire. Cette implémentation de base est, entre autres choses, chargée d’appeler le reste des gestionnaires d’activités, tels que OnMessageActivityAsync.

Le ActivityHandler JavaScript utilise un émetteur d’événement et un modèle d’écouteur. Par exemple, utilisez la méthode onMessage afin d’inscrire un écouteur d’événements pour les activités de message. Vous pouvez inscrire plusieurs écouteurs. Lorsque le bot reçoit une activité de message, le gestionnaire d’activités voit cette activité entrante et l’envoie à chacun des écouteurs d’activités onMessage, dans l’ordre dans lequel ils ont été inscrits.

Lors de la création du bot, votre logique de bot pour la gestion des messages et la réponse à ceux-ci est insérée dans les écouteurs onMessage. De la même façon, votre logique pour la gestion des membres ajoutés à la conversation est insérée dans vos écouteurs onMembersAdded, qui sont appelés chaque fois qu’un membre est ajouté à la conversation. Pour ajouter ces écouteurs, vous devez les inscrire dans votre bot comme indiqué dans la section Logique du bot ci-dessous. Pour chaque écouteur, ajoutez votre logique de bot, puis veillez à appeler next() à la fin. En appelant next(), vous êtes certain que l'écouteur suivant est exécuté.

Veillez à enregistrer l’état avant la fin du tour. Pour ce faire, vous pouvez remplacer la méthode run du gestionnaire d’activités et enregistrer l’état une fois que l’exécution de la méthode run du parent est terminée.

Généralement, il n'existe pas de situation qui justifie de vouloir remplacer le gestionnaire de tours standard, alors faites preuve de prudence si vous tentez de le faire. Il existe un gestionnaire spécial appelé onDialog. Le gestionnaire onDialog s'exécute à la fin, après l'exécution des autres gestionnaires, et n'est pas lié à un certain type d'activité. Comme pour tous les gestionnaires ci-dessus, veillez à appeler next() pour garantir la clôture du reste du processus.

Pour implémenter votre logique pour ces gestionnaires, vous allez remplacer ces méthodes dans votre bot, comme dans l'exemple de gestionnaire d'activité ci-dessous. Il n'y a pas d'implémentation de base pour chacun de ces gestionnaires, donc ajoutez la logique que vous voulez dans votre remplacement.

Il peut arriver que vous souhaitiez remplacer le gestionnaire de tours standard, comme l'enregistrement de l'état à la fin d'un tour. Lors de cette opération, veillez à appeler en premier super.onTurn(turnContext); pour vous assurer que l'implémentation de base de onTurn est exécutée avant votre code supplémentaire. Cette implémentation de base est, entre autres choses, chargée d’appeler le reste des gestionnaires d’activités, tels que onMessageActivity.

Lors de la création du bot, votre logique de bot pour la gestion des messages et leur réponse passe dans ce gestionnaire on_message_activity. De la même façon, votre logique pour la gestion des membres ajoutés à la conversation va dans votre gestionnaire on_members_added, qui est appelé chaque fois qu’un membre est ajouté à la conversation.

Par exemple, si le bot reçoit une activité de message, le gestionnaire de tours voit cette activité entrante et l’envoie au gestionnaire d’activités on_message_activity.

Pour implémenter votre logique pour ces gestionnaires, vous allez remplacer ces méthodes dans votre bot, comme dans l'exemple de gestionnaire d'activité ci-dessous. Comme aucun de ces gestionnaires ne dispose d'une implémentation de base, ajoutez simplement la logique que vous voulez dans votre remplacement.

Il peut arriver que vous souhaitiez remplacer le gestionnaire de tours standard, comme l'enregistrement de l'état à la fin d'un tour. Lors de cette opération, veillez à appeler en premier await super().on_turn(turnContext); pour vous assurer que l’implémentation de base de on_turn est exécutée avant votre code supplémentaire. Cette implémentation de base est, entre autres choses, chargée d’appeler le reste des gestionnaires d’activités, tels que on_message_activity.

La logique principale du bot est définie dans le code du bot. Pour implémenter un bot en tant que gestionnaire d'activités, dérivez votre classe de bot à partir de ActivityHandlerlaquelle implémente l'interface IBot. ActivityHandler définit divers gestionnaires pour différents types d'activités, comme OnMessageActivityAsync et OnMembersAddedAsync. Ces méthodes sont protégées, mais peuvent être remplacées dans la mesure où nous dérivons de ActivityHandler.

Les gestionnaires définis dans ActivityHandler sont :

Ces différents gestionnaires disposent de turnContext qui fournit des informations sur l’activité entrante ; celle-ci correspond à la requête HTTP entrante. Les activités pouvant être de différents types, chaque gestionnaire fournit donc une activité fortement typée dans son paramètre de contexte de tour ; dans la plupart des cas, OnMessageActivityAsync est toujours géré, et il est généralement le plus courant.

Comme dans les précédentes versions 4.x de ce framework, il existe également la possibilité d'implémenter la méthode publique OnTurnAsync. Actuellement, l’implémentation de base de cette méthode gère la vérification des erreurs, et appelle ensuite chacun des gestionnaires spécifiques (par exemple, les deux que nous définissons dans cet exemple) selon le type d’activité entrante. Bien souvent, vous pouvez ignorer cette méthode et utiliser les gestionnaires individuels, mais si votre situation nécessite une implémentation personnalisée de OnTurnAsync, elle demeure une alternative.

La logique principale du bot est définie dans le code du bot. Pour implémenter un bot en tant que gestionnaire d'activités, étendez ActivityHandler. ActivityHandler définit divers événements pour différents types d'activités, sachant que vous pouvez modifier le comportement de votre bot en inscrivant des écouteurs d'événements, par exemple avec onMessage et onConversationUpdate.

Utilisez ces méthodes pour inscrire des écouteurs pour chaque type d’événement :

Appelez la fonction de continuation next de chaque gestionnaire pour permettre la poursuite du traitement. Si next n'est pas appelé, le traitement de l'activité se termine.

La logique principale du bot est définie dans le code du bot. Pour implémenter un bot en tant que gestionnaire d'activités, dérivez votre classe de bot à partir de ActivityHandlerlaquelle implémente l'interface Bot. ActivityHandler définit divers gestionnaires pour différents types d'activités, comme onMessageActivity et onMembersAdded. Ces méthodes sont protégées, mais peuvent être remplacées dans la mesure où nous dérivons de ActivityHandler.

Les gestionnaires définis dans ActivityHandler sont :

Ces différents gestionnaires disposent de turnContext qui fournit des informations sur l’activité entrante ; celle-ci correspond à la requête HTTP entrante. Les activités pouvant être de différents types, chaque gestionnaire fournit donc une activité fortement typée dans son paramètre de contexte de tour ; dans la plupart des cas, onMessageActivity est toujours géré, et il est généralement le plus courant.

Il existe également la possibilité d'implémenter la méthode publique onTurn. Actuellement, l’implémentation de base de cette méthode gère la vérification des erreurs, et appelle ensuite chacun des gestionnaires spécifiques (par exemple, les deux que nous définissons dans cet exemple) selon le type d’activité entrante. Bien souvent, vous pouvez ignorer cette méthode et utiliser les gestionnaires individuels, mais si votre situation nécessite une implémentation personnalisée de onTurn, elle demeure une alternative.

La logique principale du bot est définie dans le code du bot. Pour implémenter un bot en tant que gestionnaire d'activité, vous devez dériver votre classe de bot ActivityHandler, qui dérive à son tour de la classe abstraite Bot. ActivityHandler définit divers gestionnaires pour différents types d'activités, comme on_message_activity et on_members_added. Ces méthodes sont protégées, mais peuvent être remplacées dans la mesure où nous dérivons de ActivityHandler.

Les gestionnaires définis dans ActivityHandler sont :

Ces différents gestionnaires disposent de turn_context qui fournit des informations sur l’activité entrante ; celle-ci correspond à la requête HTTP entrante. Les activités pouvant être de différents types, chaque gestionnaire fournit donc une activité fortement typée dans son paramètre de contexte de tour ; dans la plupart des cas, on_message_activity est toujours géré, et il est généralement le plus courant.

Comme dans les précédentes versions 4.x de ce framework, il existe également la possibilité d'implémenter la méthode publique on_turn. Actuellement, l’implémentation de base de cette méthode gère la vérification des erreurs, et appelle ensuite chacun des gestionnaires spécifiques (par exemple, les deux que nous définissons dans cet exemple) selon le type d’activité entrante. Bien souvent, vous pouvez ignorer cette méthode et utiliser les gestionnaires individuels, mais si votre situation nécessite une implémentation personnalisée de on_turn, elle demeure une alternative.

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

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