Conversazioni guidate dagli eventi usando un gestore attività

Per implementare la logica per questi gestori, è necessario eseguire l'override di questi metodi nel bot, ad esempio nella sezione del gestore attività di esempio seguente. Per ognuno di questi gestori, non è disponibile alcuna implementazione di base, quindi è sufficiente aggiungere la logica desiderata nell'override.

Esistono alcune situazioni in cui si vuole eseguire l'override del gestore dei turni di base, ad esempio il salvataggio dello stato alla fine di un turno. In tal caso, accertarsi di chiamare prima await base.OnTurnAsync(turnContext, cancellationToken); per far sì che l'implementazione di base di OnTurnAsync venga eseguita prima del proprio codice aggiuntivo. Questa implementazione di base è anche responsabile della chiamata al resto dei gestori di attività come OnMessageActivityAsync.

La classe ActivityHandler JavaScript usa un modello basato su emettitore e listener. Usare, ad esempio, il metodo onMessage per registrare un listener di eventi per le attività di messaggistica. È possibile registrare più di un listener. Quando il bot riceve un'attività di messaggistica, il gestore di attività rileverà tale attività in ingresso e la invierà a ognuno dei listener di attività di onMessage, nell'ordine in cui sono stati registrati.

Quando si compila il bot, la logica del bot per la gestione e la risposta ai messaggi verrà inserita nei listener di onMessage. Allo stesso modo, la logica di gestione dei membri aggiunti alla conversazione verrà inserita nei listener di onMembersAdded, che vengono chiamati ogni volta che un membro viene aggiunto alla conversazione. Per aggiungere questi listener, è necessario registrarli nel bot come illustrato nella sezione Logica bot seguente. Includere la logica del bot per ognuno di questi listener e quindi assicurarsi di chiamare next() al termine. next()Chiamando , assicurarsi che il listener successivo venga eseguito.

Assicurarsi di salvare lo stato prima della fine del turno. A tale scopo, eseguire l'override del metodo run del gestore attività e salvare lo stato dopo il completamento del metodo run dell'elemento padre.

Non ci sono situazioni comuni in cui si vuole eseguire l'override del gestore dei turni di base, quindi prestare attenzione se si tenta di farlo. Esiste un gestore speciale denominato onDialog. Il onDialog gestore viene eseguito alla fine, dopo l'esecuzione del resto dei gestori e non è associato a un determinato tipo di attività. Come con tutti i gestori precedenti, assicurarsi di chiamare next() per far sì che il resto del processo venga completato.

Per implementare la logica per questi gestori, è necessario eseguire l'override di questi metodi nel bot, ad esempio nella sezione del gestore attività di esempio seguente. Non esiste un'implementazione di base per ognuno di questi gestori, quindi aggiungere la logica desiderata nell'override.

Esistono alcune situazioni in cui si vuole eseguire l'override del gestore dei turni di base, ad esempio il salvataggio dello stato alla fine di un turno. In questo caso, assicurarsi di chiamare super.onTurn(turnContext); prima di tutto per assicurarsi che l'implementazione di base di venga eseguita prima del onTurn codice aggiuntivo. Questa implementazione di base è anche responsabile della chiamata al resto dei gestori di attività come onMessageActivity.

Quando si compila il bot, la logica del bot per la gestione e la risposta ai messaggi verrà inserita in questo gestore on_message_activity. Allo stesso modo, la logica di gestione dei membri aggiunti alla conversazione verrà inserita nel gestore on_members_added, che viene chiamato ogni volta che un membro viene aggiunto alla conversazione.

Se ad esempio il bot riceve un'attività di messaggistica, il gestore dei turni rileverà tale attività in ingresso e la invierà al gestore di attività on_message_activity.

Per implementare la logica per questi gestori, è necessario eseguire l'override di questi metodi nel bot, ad esempio nella sezione del gestore attività di esempio seguente. Per ognuno di questi gestori, non è disponibile alcuna implementazione di base, quindi è sufficiente aggiungere la logica desiderata nell'override.

Esistono alcune situazioni in cui si vuole eseguire l'override del gestore dei turni di base, ad esempio il salvataggio dello stato alla fine di un turno. In tal caso, accertarsi di chiamare prima await super().on_turn(turnContext); per far sì che l'implementazione di base di on_turn venga eseguita prima del proprio codice aggiuntivo. Questa implementazione di base è anche responsabile della chiamata al resto dei gestori di attività come on_message_activity.

La logica principale del bot è definita nel codice del bot. Per implementare un bot come gestore attività, derivare la classe bot da ActivityHandler, che implementa l'interfaccia IBot . ActivityHandler definisce vari gestori per diversi tipi di attività, ad esempio OnMessageActivityAsync, e OnMembersAddedAsync. Questi metodi sono protetti, ma possono essere sottoposti a override, poiché si deriva da ActivityHandler.

I gestori definiti in ActivityHandler sono:

Questi gestori diversi hanno un turnContext che fornisce informazioni sull'attività in ingresso, corrispondente alla richiesta HTTP in ingresso. Le attività possono essere di vario tipo, quindi ogni gestore fornisce un'attività fortemente tipizzata nel relativo parametro di contesto del turno. Nella maggior parte dei casi, OnMessageActivityAsync verrà sempre gestito ed è generalmente il più comune.

Come nelle versioni precedenti della versione 4.x di questo framework, è anche possibile implementare il metodo OnTurnAsyncpubblico . L'implementazione di base di questo metodo gestisce attualmente il controllo degli errori e quindi chiama ognuno dei gestori specifici (ad esempio, i due definiti in questo esempio) a seconda del tipo di attività in ingresso. Nella maggior parte dei casi, è possibile lasciare il metodo da solo e usare i singoli gestori, ma se la situazione richiede un'implementazione personalizzata di OnTurnAsync, è comunque un'opzione.

La logica principale del bot è definita nel codice del bot. Per implementare un bot come gestore attività, estendere ActivityHandler. ActivityHandler definisce vari eventi per diversi tipi di attività ed è possibile modificare il comportamento del bot registrando listener di eventi, ad esempio con onMessage e onConversationUpdate.

Usare questi metodi per registrare i listener per ogni tipo di evento:

Chiamare la funzione di continuazione next da ogni gestore per consentire la continuazione dell'elaborazione. Se next non viene chiamato, l'elaborazione dell'attività termina.

La logica principale del bot è definita nel codice del bot. Per implementare un bot come gestore attività, derivare la classe bot da ActivityHandler, che implementa l'interfaccia Bot . ActivityHandler definisce vari gestori per diversi tipi di attività, ad esempio onMessageActivity, e onMembersAdded. Questi metodi sono protetti, ma possono essere sottoposti a override, poiché si deriva da ActivityHandler.

I gestori definiti in ActivityHandler sono:

Questi gestori diversi hanno un turnContext che fornisce informazioni sull'attività in ingresso, corrispondente alla richiesta HTTP in ingresso. Le attività possono essere di vario tipo, quindi ogni gestore fornisce un'attività fortemente tipizzata nel relativo parametro di contesto del turno. Nella maggior parte dei casi, onMessageActivity verrà sempre gestito ed è generalmente il più comune.

È anche disponibile l'opzione per implementare il metodo onTurnpubblico . L'implementazione di base di questo metodo gestisce attualmente il controllo degli errori e quindi chiama ognuno dei gestori specifici (ad esempio, i due definiti in questo esempio) a seconda del tipo di attività in ingresso. Nella maggior parte dei casi, è possibile lasciare il metodo da solo e usare i singoli gestori, ma se la situazione richiede un'implementazione personalizzata di onTurn, è comunque un'opzione.

La logica principale del bot è definita nel codice del bot. Per implementare un bot come gestore attività, derivare la classe bot da ActivityHandler, che a sua volta deriva dalla classe astratta Bot . ActivityHandler definisce vari gestori per diversi tipi di attività, ad esempio on_message_activity e on_members_added. Questi metodi sono protetti, ma possono essere sottoposti a override, poiché si deriva da ActivityHandler.

I gestori definiti in ActivityHandler sono:

Questi gestori diversi hanno un turn_context che fornisce informazioni sull'attività in ingresso, corrispondente alla richiesta HTTP in ingresso. Le attività possono essere di vario tipo, quindi ogni gestore fornisce un'attività fortemente tipizzata nel relativo parametro di contesto del turno. Nella maggior parte dei casi, on_message_activity verrà sempre gestito ed è generalmente il più comune.

Come nelle versioni precedenti della versione 4.x di questo framework, è anche possibile implementare il metodo on_turnpubblico . L'implementazione di base di questo metodo gestisce attualmente il controllo degli errori e quindi chiama ognuno dei gestori specifici (ad esempio, i due definiti in questo esempio) a seconda del tipo di attività in ingresso. Nella maggior parte dei casi, è possibile lasciare il metodo da solo e usare i singoli gestori, ma se la situazione richiede un'implementazione personalizzata di on_turn, è comunque un'opzione.

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