Gerenciar a complexidade da caixa de diálogo

Para usar caixas de diálogo, instale o pacote NuGet Microsoft.Bot.Builder.Dialogs .

Caixas de diálogo\UserProfileDialog.cs

Aqui a UserProfileDialog classe deriva da ComponentDialog classe.

public class UserProfileDialog : ComponentDialog

Dentro do construtor, o AddDialog método adiciona diálogos e prompts para a caixa de diálogo do componente. O primeiro item adicionado com esse método é definido como a caixa de diálogo inicial. Você pode alterar a caixa de diálogo inicial definindo explicitamente a InitialDialogId propriedade. Quando você inicia uma caixa de diálogo de componente, ela inicia sua caixa de diálogo inicial.

public UserProfileDialog(UserState userState)
    : base(nameof(UserProfileDialog))
{
    _userProfileAccessor = userState.CreateProperty<UserProfile>("UserProfile");

    // This array defines how the Waterfall will execute.
    var waterfallSteps = new WaterfallStep[]
    {
        TransportStepAsync,
        NameStepAsync,
        NameConfirmStepAsync,
        AgeStepAsync,
        PictureStepAsync,
        SummaryStepAsync,
        ConfirmStepAsync,
    };

    // Add named dialogs to the DialogSet. These names are saved in the dialog state.
    AddDialog(new WaterfallDialog(nameof(WaterfallDialog), waterfallSteps));
    AddDialog(new TextPrompt(nameof(TextPrompt)));
    AddDialog(new NumberPrompt<int>(nameof(NumberPrompt<int>), AgePromptValidatorAsync));
    AddDialog(new ChoicePrompt(nameof(ChoicePrompt)));
    AddDialog(new ConfirmPrompt(nameof(ConfirmPrompt)));
    AddDialog(new AttachmentPrompt(nameof(AttachmentPrompt), PicturePromptValidatorAsync));

    // The initial child Dialog to run.
    InitialDialogId = nameof(WaterfallDialog);
}

O código a seguir representa a primeira etapa da caixa de diálogo em cascata.

private static async Task<DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    stepContext.Values["transport"] = ((FoundChoice)stepContext.Result).Value;

    return await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = MessageFactory.Text("Please enter your name.") }, cancellationToken);
}

Para obter mais informações sobre como implementar caixas de diálogo em cascata, consulte como implementar o fluxo de conversação sequencial.

Para usar diálogos, seu projeto precisa instalar o pacote npm botbuilder-dialogs .

diálogos/userProfileDialog.js

Aqui a UserProfileDialog aula se estende.ComponentDialog

class UserProfileDialog extends ComponentDialog {

Dentro do construtor, o AddDialog método adiciona diálogos e prompts para a caixa de diálogo do componente. O primeiro item adicionado com esse método é definido como a caixa de diálogo inicial. Você pode alterar a caixa de diálogo inicial definindo explicitamente a InitialDialogId propriedade. Quando você inicia uma caixa de diálogo de componente, ela inicia sua caixa de diálogo inicial.

constructor(userState) {
    super('userProfileDialog');

    this.userProfile = userState.createProperty(USER_PROFILE);

    this.addDialog(new TextPrompt(NAME_PROMPT));
    this.addDialog(new ChoicePrompt(CHOICE_PROMPT));
    this.addDialog(new ConfirmPrompt(CONFIRM_PROMPT));
    this.addDialog(new NumberPrompt(NUMBER_PROMPT, this.agePromptValidator));
    this.addDialog(new AttachmentPrompt(ATTACHMENT_PROMPT, this.picturePromptValidator));

    this.addDialog(new WaterfallDialog(WATERFALL_DIALOG, [
        this.transportStep.bind(this),
        this.nameStep.bind(this),
        this.nameConfirmStep.bind(this),
        this.ageStep.bind(this),
        this.pictureStep.bind(this),
        this.summaryStep.bind(this),
        this.confirmStep.bind(this)
    ]));

    this.initialDialogId = WATERFALL_DIALOG;
}

O código a seguir representa a primeira etapa da caixa de diálogo em cascata.

async transportStep(step) {
    // WaterfallStep always finishes with the end of the Waterfall or with another dialog; here it is a Prompt Dialog.
    // Running a prompt here means the next WaterfallStep will be run when the user's response is received.
    return await step.prompt(CHOICE_PROMPT, {
        prompt: 'Please enter your mode of transport.',
        choices: ChoiceFactory.toChoices(['Car', 'Bus', 'Bicycle'])
    });
}

Para obter mais informações sobre como implementar caixas de diálogo em cascata, consulte como implementar o fluxo de conversação sequencial.

UserProfileDialog.java

Aqui a UserProfileDialog classe deriva da ComponentDialog classe.

public class UserProfileDialog extends ComponentDialog {

Dentro do construtor, o addDialog método adiciona diálogos e prompts para a caixa de diálogo do componente. O primeiro item adicionado com esse método é definido como a caixa de diálogo inicial. Você pode alterar a caixa de diálogo inicial chamando o setInitialDialogId método e fornecendo o nome da caixa de diálogo inicial. Quando você inicia uma caixa de diálogo de componente, ela inicia sua caixa de diálogo inicial.

public UserProfileDialog(UserState withUserState) {
    super("UserProfileDialog");

    userProfileAccessor = withUserState.createProperty("UserProfile");

    WaterfallStep[] waterfallSteps = {
        UserProfileDialog::transportStep,
        UserProfileDialog::nameStep,
        this::nameConfirmStep,
        this::ageStep,
        UserProfileDialog::pictureStep,
        this::confirmStep,
        this::summaryStep
    };

    // Add named dialogs to the DialogSet. These names are saved in the dialog state.
    addDialog(new WaterfallDialog("WaterfallDialog", Arrays.asList(waterfallSteps)));
    addDialog(new TextPrompt("TextPrompt"));
    addDialog(new NumberPrompt<Integer>("NumberPrompt", UserProfileDialog::agePromptValidator, Integer.class));
    addDialog(new ChoicePrompt("ChoicePrompt"));
    addDialog(new ConfirmPrompt("ConfirmPrompt"));
    addDialog(new AttachmentPrompt("AttachmentPrompt", UserProfileDialog::picturePromptValidator));

    // The initial child Dialog to run.
    setInitialDialogId("WaterfallDialog");
}

O código a seguir representa a primeira etapa da caixa de diálogo em cascata.

private static CompletableFuture<DialogTurnResult> nameStep(WaterfallStepContext stepContext) {
    stepContext.getValues().put("transport", ((FoundChoice) stepContext.getResult()).getValue());

    PromptOptions promptOptions = new PromptOptions();
    promptOptions.setPrompt(MessageFactory.text("Please enter your name."));
    return stepContext.prompt("TextPrompt", promptOptions);
}

Para obter mais informações sobre como implementar caixas de diálogo em cascata, consulte como implementar o fluxo de conversação sequencial.

Para usar diálogos, instale os pacotes botbuilder-dialogs e botbuilder-ai PyPI executando pip install botbuilder-dialogs e pip install botbuilder-ai a partir de um terminal.

diálogos/user_profile_dialog.py

Aqui a UserProfileDialog aula se estende.ComponentDialog

class UserProfileDialog(ComponentDialog):

Dentro do construtor, o add_dialog método adiciona diálogos e prompts para a caixa de diálogo do componente. O primeiro item adicionado com esse método é definido como a caixa de diálogo inicial. Você pode alterar a caixa de diálogo inicial definindo explicitamente a initial_dialog_id propriedade. Quando você inicia uma caixa de diálogo de componente, ela inicia sua caixa de diálogo inicial.

class UserProfileDialog(ComponentDialog):
    def __init__(self, user_state: UserState):
        super(UserProfileDialog, self).__init__(UserProfileDialog.__name__)

        self.user_profile_accessor = user_state.create_property("UserProfile")

        self.add_dialog(
            WaterfallDialog(
                WaterfallDialog.__name__,
                [
                    self.transport_step,
                    self.name_step,
                    self.name_confirm_step,
                    self.age_step,
                    self.picture_step,
                    self.summary_step,
                    self.confirm_step,
                ],
            )
        )
        self.add_dialog(TextPrompt(TextPrompt.__name__))
        self.add_dialog(
            NumberPrompt(NumberPrompt.__name__, UserProfileDialog.age_prompt_validator)
        )
        self.add_dialog(ChoicePrompt(ChoicePrompt.__name__))
        self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__))
        self.add_dialog(
            AttachmentPrompt(
                AttachmentPrompt.__name__, UserProfileDialog.picture_prompt_validator
            )
        )

        self.initial_dialog_id = WaterfallDialog.__name__

O código a seguir representa a primeira etapa da caixa de diálogo em cascata.

async def transport_step(
    self, step_context: WaterfallStepContext
) -> DialogTurnResult:
    # WaterfallStep always finishes with the end of the Waterfall or with another dialog;
    # here it is a Prompt Dialog. Running a prompt here means the next WaterfallStep will
    # be run when the users response is received.
    return await step_context.prompt(
        ChoicePrompt.__name__,
        PromptOptions(
            prompt=MessageFactory.text("Please enter your mode of transport."),
            choices=[Choice("Car"), Choice("Bus"), Choice("Bicycle")],
        ),
    )

Para obter mais informações sobre como implementar caixas de diálogo em cascata, consulte como implementar o fluxo de conversação sequencial.

Bots\DialogBot.cs

No exemplo, isso é feito usando o RunAsync método que é chamado a partir do método do OnMessageActivityAsync bot.

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    Logger.LogInformation("Running dialog with Message Activity.");

    // Run the Dialog with the new message Activity.
    await Dialog.RunAsync(turnContext, ConversationState.CreateProperty<DialogState>(nameof(DialogState)), cancellationToken);
}

diálogos/userProfileDialog.js

No exemplo, adicionamos um run método à caixa de diálogo de perfil de usuário.

async run(turnContext, accessor) {
    const dialogSet = new DialogSet(accessor);
    dialogSet.add(this);

    const dialogContext = await dialogSet.createContext(turnContext);
    const results = await dialogContext.continueDialog();
    if (results.status === DialogTurnStatus.empty) {
        await dialogContext.beginDialog(this.id);
    }
}

bots/dialogBot.js

O run método é chamado a partir do método do onMessage bot.

this.onMessage(async (context, next) => {
    console.log('Running dialog with Message Activity.');

    // Run the Dialog with the new message Activity.
    await this.dialog.run(context, this.dialogState);

    await next();
});

DialogBot.java

No exemplo, isso é feito usando o run método que é chamado a partir do método do onMessageActivity bot.

@Override
protected CompletableFuture<Void> onMessageActivity(
    TurnContext turnContext
) {
    LoggerFactory.getLogger(DialogBot.class).info("Running dialog with Message Activity.");

    // Run the Dialog with the new message Activity.
    return Dialog.run(dialog, turnContext, conversationState.createProperty("DialogState"));
}

ajudantes/dialog_helper.py

No exemplo, adicionamos um run_dialog método à caixa de diálogo de perfil de usuário.

class DialogHelper:
    @staticmethod
    async def run_dialog(
        dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor
    ):
        dialog_set = DialogSet(accessor)
        dialog_set.add(dialog)

        dialog_context = await dialog_set.create_context(turn_context)
        results = await dialog_context.continue_dialog()
        if results.status == DialogTurnStatus.Empty:
            await dialog_context.begin_dialog(dialog.id)

O run_dialog método que é chamado a partir do método do on_message_activity bot.

bots/dialog_bot.py

async def on_message_activity(self, turn_context: TurnContext):
    await DialogHelper.run_dialog(
        self.dialog,
        turn_context,
        self.conversation_state.create_property("DialogState"),
    )