在瀑布对话框中捕获 Adaptive Card 提交的值

Question

我已经听从了this question 的建议，this issue 的评论以及this answer 的评论。

在我的瀑布对话框中：

• 显示自适应卡片
• 显示自适应卡片后立即发送文本提示

在我的主要机器人类中：

• 如果活动是包含回发数据的消息，则将Activity 的Text 属性设置为从活动的Value 属性中提取的值。

我曾尝试使用AdaptiveTextInput 或AdaptiveDateInput 作为控件来提交值，但这并没有什么不同。我觉得这将是一件非常愚蠢的事情..

我目前在我的瀑布中使用Hero 和Adaptive 卡的组合，Hero 卡可以正常工作。

---

编辑

我已将 // !Relevant- cmets 添加到我的代码中的重要部分，其余部分留作上下文。

所以我的问题是：是什么阻止了我在自适应卡片上的提交正确地通过 - 是我在瀑布中的显示方式有问题，还是卡片中的动作构造有问题，或者我如何正在处理主要机器人类中的操作？

---

在AdaptiveCardService 中构建我的卡片：

public List<Activity> BuildCardActivitiesFromDecisionFlow(BotDecisionFlow botDecisionFlow)
{
    List<Activity> cardActivities = new List<Activity>();

    foreach (Step step in botDecisionFlow.FormSchema.Steps)
    {
        Control control = step.Details.Control;

        cardActivities.Add(CreateCardActivity(step, control));
    }

    return cardActivities;
}

private Activity CreateCardActivity(Step step, Control control)
{
    Activity cardActivity = (Activity)Activity.CreateMessageActivity();

    if (control.Type == ControlTypeEnum.RadioButton)
    {
        HeroCard heroCard = BuildHeroCard(step, control.DataType);
        Attachment attachment = heroCard.ToAttachment();

        cardActivity.Attachments.Add(attachment);
    }
    else if (control.Type == ControlTypeEnum.DatePicker)
    {
        AdaptiveCard adaptiveCard = BuildAdaptiveCard(step, control.DataType);

        Attachment attachment = new Attachment
        {
            ContentType = AdaptiveCard.ContentType,
            // Trick to get Adapative Cards to work with prompts as per https://github.com/Microsoft/botbuilder-dotnet/issues/614#issuecomment-443549810
            Content = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(adaptiveCard))
        };

        cardActivity.Attachments.Add(attachment);
    }
    else
    {
        throw new NotImplementedException($"The {nameof(control)} with value {control} is not yet supported.");
    }

    return cardActivity;
}

private HeroCard BuildHeroCard(Step step, DataTypeEnum dataType)
{
    string question = step.Details.Question;

    HeroCard heroCard = new HeroCard
    {
        Text = question,
        // PostBack is required to get buttons to work with prompts, also the value needs to be a string for the
        // event to fire properly, as per https://stackoverflow.com/a/56297792/5209435
        Buttons = step.Details.EnumValueToDisplayTextMappings.Select(e => new CardAction(ActionTypes.PostBack, e.Value, null, e.Value, e.Value, JsonConvert.SerializeObject(new DialogValueDto(step.Name, e.Key, dataType)), null)).ToList()
    };

    return heroCard;
}

private AdaptiveCard BuildAdaptiveCard(Step step, DataTypeEnum dataType)
{
    const string ISO8601Format = "yyyy-MM-dd";
    string question = step.Details.Question;

    DateTime today = DateTime.Today;
    string todayAsIso = today.ToString(ISO8601Format);

    AdaptiveCard adaptiveCard = new AdaptiveCard("1.0")
    {
        Body =
        {
            new AdaptiveContainer
            {
                Items =
                {
                    new AdaptiveTextBlock
                    {
                        Text = question,
                        Wrap = true
                    },
                    new AdaptiveDateInput
                    {
                        Id = "UserInput",
                        Value = todayAsIso,
                        Min = today.AddDays(-7).ToString(ISO8601Format),
                        Max = todayAsIso,
                        Placeholder = todayAsIso
                    }
                }
            }
        },
        Actions = new List<AdaptiveAction>
        {
            // !Relevant-Start
            new AdaptiveSubmitAction
            {
                Data = new DialogValueDto(step.Name, dataType),
                Title = "Confirm",
                Type = "Action.Submit"
            }
            // !Relevant-End
        }
    };

    return adaptiveCard;
}

在我的瀑布类中：

private readonly IUmbracoApiWrapper _umbracoApiWrapper;
    private readonly IUmbracoResponseConverterService _umbracoResponseConverterService;
    private readonly IAdaptiveCardService _adaptiveCardService;

    private IStatePropertyAccessor<DynamicWaterfallState> _accessor;
    private DynamicWaterfallState _state;

    public DynamicWaterfallDialog(
        IUmbracoApiWrapper umbracoApiWrapper,
        IUmbracoResponseConverterService umbracoResponseConverterService,
        IAdaptiveCardService adaptiveCardService,
        UserState userState)
        : base(nameof(DynamicWaterfallDialog))
    {
        _accessor = userState.CreateProperty<DynamicWaterfallState>(nameof(DynamicWaterfallState));
        _umbracoApiWrapper = umbracoApiWrapper;
        _umbracoResponseConverterService = umbracoResponseConverterService;
        _adaptiveCardService = adaptiveCardService;

        InitialDialogId = nameof(WaterfallDialog);

        // !Relevant-Start
        var waterfallSteps = new WaterfallStep[]
        {
            // TODO: Rename this DisplayCardAsync
            UserInputStepAsync,
            // TODO: Rename this ProcessCardAsync
            LoopStepAsync,
        };

        AddDialog(new TextPrompt(nameof(TextPrompt)));
        AddDialog(new WaterfallDialog(InitialDialogId, waterfallSteps));
        // !Relevant-End
    }

    // TODO: Does it make more sense for the collection of dialogs to be passed in? It depends on how this dialog is going to be called, 
    // maybe just passing in the ID is fine rather than having code sprinkled around to fetch the dialog collections.
    public async Task<DialogTurnResult> UserInputStepAsync(WaterfallStepContext sc, CancellationToken cancellationToken)
    {
        // Get passed in options, need to serialise the object before we deserialise because calling .ToString on the object is unreliable
        string tempData = JsonConvert.SerializeObject(sc.Options);
        DynamicWaterfallDialogDto dynamicWaterfallDialogDto = JsonConvert.DeserializeObject<DynamicWaterfallDialogDto>(tempData);

        // Read out data from the state
        _state = await _accessor.GetAsync(sc.Context, () => new DynamicWaterfallState());

        List<Activity> activityCards = _state.ActivityDialogs ?? new List<Activity>();
        int dialogPosition = _state.DialogPosition;
        bool flowFinished = _state.FlowFinished;
        bool apiDataFetched = _state.ApiDataFetched;

        if (DynamicWaterfallDialogDtoExtensions.IsDynamicWaterfallDialogDtoValid(dynamicWaterfallDialogDto) && !apiDataFetched)
        {
            // Fetch from API
            JObject decision = await _umbracoApiWrapper.GetDecisionById(18350);

            UmbracoDecisionResponseDto umbracoResponseDto = JsonConvert.DeserializeObject<UmbracoDecisionResponseDto>(decision.ToString());

            BotDecisionFlow botDecisionFlow = new BotDecisionFlow(_umbracoResponseConverterService, umbracoResponseDto);

            activityCards = _adaptiveCardService.BuildCardActivitiesFromDecisionFlow(botDecisionFlow);

            _state.ApiDataFetched = true;
            _state.ActivityDialogs = activityCards;

            await _accessor.SetAsync(sc.Context, _state, cancellationToken);
        }

        var cardToShow = activityCards.ElementAt(dialogPosition);

        _state.FlowFinished = _state.DialogPosition == activityCards.Count - 1;
        _state.DialogPosition++;

        await _accessor.SetAsync(sc.Context, _state, cancellationToken);

        // TODO we need to determine the control type to figure out the prompt type?

        // !Relevant-Start
        await sc.Context.SendActivityAsync(cardToShow);
        return await sc.PromptAsync(nameof(TextPrompt), new PromptOptions() { Prompt = MessageFactory.Text("") });
        //return await sc.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = new Activity { Type = ActivityTypes.Message } });
        // !Relevant-End
    }

    public async Task<DialogTurnResult> LoopStepAsync(WaterfallStepContext sc, CancellationToken cancellationToken)
    {
        object result = sc.Result;
        DialogValueDto userInput = JsonConvert.DeserializeObject<DialogValueDto>(sc.Result.ToString());

        await sc.Context.SendActivityAsync($"You selected: {userInput.UserInput}");

        _state = await _accessor.GetAsync(sc.Context, () => new DynamicWaterfallState());

        bool flowFinished = _state.FlowFinished;

        // TODO: Do we want to do state manipulation in here?

        if (!flowFinished)
        {
            // TODO: Do we want to pass in custom options here?
            return await sc.ReplaceDialogAsync(nameof(DynamicWaterfallDialog), sc.Options, cancellationToken);
        }
        else
        {
            // TODO: We probably want to pass the state in here instead of null if we want to show outcomes etc
            return await sc.EndDialogAsync(null, cancellationToken);
        }
    }
}

在我的主要机器人类中：

public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
    // Client notifying this bot took to long to respond (timed out)
    if (turnContext.Activity.Code == EndOfConversationCodes.BotTimedOut)
    {
        _telemetryClient.TrackTrace($"Timeout in {turnContext.Activity.ChannelId} channel: Bot took too long to respond.", Severity.Information, null);
        return;
    }

    var dc = await _dialogs.CreateContextAsync(turnContext);

    // !Relevant-Start
    if (turnContext.Activity.Type == ActivityTypes.Message)
    {
        // Ensure that message is a postBack (like a submission from Adaptive Cards)
        if (dc.Context.Activity.GetType().GetProperty("ChannelData") != null)
        {
            var channelData = JObject.Parse(dc.Context.Activity.ChannelData.ToString());

            // TODO: Add check for type, we should only handle adaptive cards here
            if (channelData.ContainsKey("postBack"))
            {
                var postbackActivity = dc.Context.Activity;

                string text = JsonConvert.DeserializeObject<DialogValueDto>(postbackActivity.Value.ToString())?.UserInput;


                // Convert the user's Adaptive Card input into the input of a Text Prompt
                // Must be sent as a string
                postbackActivity.Text = text;
                await dc.Context.SendActivityAsync(postbackActivity);
            }
        }
    }
    // !Relevant-End

    if (dc.ActiveDialog != null)
    {
        var result = await dc.ContinueDialogAsync();
    }
    else
    {
        await dc.BeginDialogAsync(typeof(T).Name);
    }
}

我的 DialogValueD 以防您需要它：

public string StepName { get; set; }
public string UserInput { get; set; }
public DataTypeEnum DataType { get; set; }

/// <summary>
/// For JSON deserialization
/// </summary>
public DialogValueDto()
{
}

/// <summary>
/// For use with DateTime deserialization.
/// The control id is set to "UserInput"
/// so this property will be set automatically
/// </summary>
public DialogValueDto(string stepName, DataTypeEnum dataType)
{
    StepName = stepName;
    DataType = dataType;
}

/// <summary>
/// This is the constructor that should be used most
/// of the time
/// </summary>
public DialogValueDto(string stepName, string userInput, DataTypeEnum dataType)
{
    StepName = stepName;
    UserInput = userInput;
    DataType = dataType;
}

有趣的是，当我设置活动的文本属性时，我的 MainDialog 的 OnEventAsync 函数（通过 Startup.cs 连接到 services.AddTransient<IBot, DialogBot<MainDialog>>(); 的函数）被触发。

Answer 1

我的问题原来是双重的

---

1) 在我的DialogBot 文件中的OnTurnAsync 方法中，我有：

var postbackActivity = dc.Context.Activity;
string text = JsonConvert.DeserializeObject<DialogValueDto>(postbackActivity.Value.ToString())?.UserInput;

postbackActivity.Text = text;
await dc.Context.SendActivityAsync(postbackActivity);

我正在设置postBackActivity 变量的Text 属性，而不是直接在dc.Context.Activity 上直接设置Text 属性。因为我是通过SendActivityAsync 发送变量，所以它掩盖了这个错误，因为我在MainDialog 类中获得了我想要传递给OnEventAsync 方法的值。

正确的方法是直接在上下文中设置它，而不是在它的副本上（DOH！）

dc.Context.Activity.Text = text

---

2) 在我的MainDialog 类的OnEventAsync 方法中，我有一个空块，它捕获了响应，但什么也没做（它需要调用await dc.ContinueDialogAsync()）。但是，这已经由虚拟助手模板中的现有代码块处理，我的空块阻止被命中。

object value = dc.Context.Activity.Value;

if (condition)
{
    // do nothing
}
else if (value.GetType() == typeof(JObject))
{
    // code from the Virtual Assistant template to check the values passed through
    var submit = JObject.Parse(value.ToString());

    // more template code

    // Template code
    if (forward)
    {
        var result = await dc.ContinueDialogAsync();

        if (result.Status == DialogTurnStatus.Complete)
        {
            await CompleteAsync(dc);
        }
    }
}

一旦我删除了我的空 if 块，它就会进入它需要的代码（前向部分）。

---

变更清单：

DynamicWaterfallDialog:

public DynamicWaterfallDialog(
    ...
    )
    : base(nameof(DynamicWaterfallDialog))
{
    ...

    InitialDialogId = nameof(WaterfallDialog);

    var waterfallSteps = new WaterfallStep[]
    {
        UserInputStepAsync,
        LoopStepAsync,
    };

    AddDialog(new TextPrompt(nameof(TextPrompt)));
    AddDialog(new WaterfallDialog(InitialDialogId, waterfallSteps));
}

DialogBot:

public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
    ...

    var dc = await _dialogs.CreateContextAsync(turnContext);

    if (dc.Context.Activity.Type == ActivityTypes.Message)
    {
        // Ensure that message is a postBack (like a submission from Adaptive Cards)
        if (dc.Context.Activity.GetType().GetProperty("ChannelData") != null)
        {
            JObject channelData = JObject.Parse(dc.Context.Activity.ChannelData.ToString());
            Activity postbackActivity = dc.Context.Activity;

            if (channelData.ContainsKey("postBack") && postbackActivity.Value != null)
            {
                DialogValueDto dialogValueDto = JsonConvert.DeserializeObject<DialogValueDto>(postbackActivity.Value.ToString());

                // Only set the text property for adaptive cards because the value we want, and the value that the user submits comes through the
                // on the Value property for adaptive cards, instead of the text property like everything else
                if (DialogValueDtoExtensions.IsValidDialogValueDto(dialogValueDto) && dialogValueDto.CardType == CardTypeEnum.Adaptive)
                {
                    // Convert the user's Adaptive Card input into the input of a Text Prompt, must be sent as a string
                    dc.Context.Activity.Text = JsonConvert.SerializeObject(dialogValueDto);

                    // We don't need to post the text as per https://stackoverflow.com/a/56010355/5209435 because this is automatically handled inside the
                    // OnEventAsync method of MainDialog.cs
                }
            }
        }
    }

    if (dc.ActiveDialog != null)
    {
        var result = await dc.ContinueDialogAsync();
    }
    else
    {
        await dc.BeginDialogAsync(typeof(T).Name);
    }
}

MainDialog:

protected override async Task OnEventAsync(DialogContext dc, CancellationToken cancellationToken = default(CancellationToken))
{
    object value = dc.Context.Activity.Value;

    if (value.GetType() == typeof(JObject))
    {
        var submit = JObject.Parse(value.ToString());
        if (value != null)
        {
            // Null propagation here is to handle things like dynamic adaptive cards that submit objects
            string action = submit["action"]?.ToString();

            ...
        }

        var forward = true;
        var ev = dc.Context.Activity.AsEventActivity();

        // Null propagation here is to handle things like dynamic adaptive cards that may not convert into an EventActivity
        if (!string.IsNullOrWhiteSpace(ev?.Name))
        {
            ...
        }

        if (forward)
        {
            var result = await dc.ContinueDialogAsync();

            if (result.Status == DialogTurnStatus.Complete)
            {
                await CompleteAsync(dc);
            }
        }
    }
}

我想我希望在上下文中设置 Text 属性以自动触发到我的 LoopStepAsync (DynamicWaterfallDialog) 处理程序，而不是陷入 OnEventAsync (MainDialog)。我知道我需要在某个地方打电话给ContinueDialogAsync，并且应该对我问题的最后一段更加怀疑：

有趣的是，当我设置活动的文本属性时，我的 MainDialog 的 OnEventAsync 函数（通过 services.AddTransient>(); 在 Startup.cs 中连接的函数）被触发。

如此接近，却又如此遥远。希望这可以帮助其他人在未来。

我发现有用的链接是：

• ComplexDialogBot.cs。
• Question about adaptive cards and waterfalls。
• GitHub issue about Adaptive Cards and prompts。