Lab 2: Build Data Collection Flow & Adaptive Card

Abstract

In this lab, we will manage a basic conversation using Dialogs. We’ll start with basic dialogs, demonstrating how dialogs are layered. We’ll finish off by using a WaterfallDialog to create a survey that connects to Azure Machine Learning to predict success in treatment for back pain.

Upon completion, developers should have:

Manage conversations with dialogs
Use accessors to persist dialog state between turns
Validate dialog input
Use prompts to to enrich dialogs
Connect to machine learning
Complete dialogs
Enhance dialog experiences with adaptive cards

Module 1: Add Dialog

Exercise 1: Bootstrap Project

L2M1E1 Step 1

Navigate to https://github.com/BlueMetal/BackMeUpBIAD, Click on “Clone or download” and choose the option most appropriate to get the code.

L2M1E1 Step 2

Once you’ve pulled down the code, copy the “BackMeUp” folder from the path “\labs\lab2\start-here”. In the copy of the project, open BackMeUp.sln

L2M1E1 Step 3

Update all NuGet packages

L2M1E1 Step 4

Open BackMeUp.cs and replace the line

var responseMessage = "Placeholder";

with

var responseMessage = "Hello, World!";

L2M1E1 Step 5

Run the code and test it using the Bot Framework Emulator

Exercise 2: Add a Simple Dialog

L2M1E2 Step 1

Add the Microsoft.Bot.Builder.Dialogs NuGet package

L2M1E2 Step 2

Create a “Dialogs” folder in the project and add the file DialogAccessors.cs to it. Paste the following code into the file

using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Dialogs;

namespace BackMeUp.Dialogs
{
    public class DialogAccessors
    {
        public DialogAccessors(ConversationState conversationState)
        {
            ConversationState = conversationState;
        }

        public static string DialogStateName { get; } = $"{nameof(DialogAccessors)}.{nameof(DialogState)}";

        public IStatePropertyAccessor<DialogState> DialogState { get; set; }

        public ConversationState ConversationState { get; }
    }
}

L2M1E2 Step 3

Add CreateDialogAccessors method to Startup.cs

public DialogAccessors CreateDialogAccessors(IServiceProvider serviceProvider)
{
    var options = serviceProvider.GetRequiredService<IOptions<BotFrameworkOptions>>().Value;
    if (options == null)
    {
        throw new InvalidOperationException(
            "BotFrameworkOptions must be configured prior to setting up the state accessors");
    }

    var conversationState = options.State.OfType<ConversationState>().FirstOrDefault();
    if (conversationState == null)
    {
        throw new InvalidOperationException(
            "ConversationState must be defined and added before adding conversation-scoped state accessors.");
    }

    var accessors = new DialogAccessors(conversationState)
    {
        DialogState = conversationState.CreateProperty<DialogState>(DialogAccessors.DialogStateName),
    };

    return accessors;
}

L2M1E2 Step 4

Add the following line to the end of the ConfigureServices method in Startup.cs

services.AddSingleton(CreateDialogAccessors);

L2M1E2 Step 5

Add “DialogAccessors accessors” to the constructor signature of BackMeUp.cs, and capture it as a field “_accessors”

L2M1E2 Step 6

Add the field “private readonly DialogSet _dialogs;” to the BackMeUp.cs class

L2M1E2 Step 7

Add the following lines to the constructor

_dialogs = new DialogSet(_accessors.DialogState);
_dialogs.Add(new ConfirmPrompt("does-it-hurt"));

L2M1E2 Step 8

Replace the body of “OnTurnAsync” with the following code

if (turnContext.Activity.Type == ActivityTypes.Message)
{
    var dialogContext = await _dialogs.CreateContextAsync(turnContext, cancellationToken);
    var dialogStatus = DialogTurnStatus.Empty;
    if (dialogContext.Dialogs != null)
    {
        var results = await dialogContext.ContinueDialogAsync(cancellationToken);
        dialogStatus = results.Status;
    }

    // We are not in a dialog, so resume turns as normal
    if (dialogStatus == DialogTurnStatus.Empty)
    {
        var activityText = turnContext.Activity.Text.Trim().ToLowerInvariant();

        // start the dialog. We'll do better when we integrate LUIS
        if (new[] { "back pain", "start" }.Any(t => t == activityText))
        {
            // the prompt to show to the user when presenting them with the dialog
            var prompt = new PromptOptions
            {
                Prompt = MessageFactory.Text("Would you like to take a survey?"),
            };

            // Starts the dialog using the provided prompt
            var result = await dialogContext.PromptAsync("does-it-hurt", prompt, cancellationToken);
        }
        else
        {
            var responseMessage = MessageFactory.Text($"You said \"{turnContext.Activity.Text}\"");
            await turnContext.SendActivityAsync(responseMessage, cancellationToken);
        }
    }
}
else
{
    await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected");
}

L2M1E2 Step 9

Run the code and test it. Type “back pain” at the prompt and see what happens. Ask your instructor or a partner before continuing if you don’t understand what is happening.

Exercise 3: Add a Waterfall Dialog

L2M1E3 Step 1

Add a “BackPain” folder under the “Dialogs” folder

L2M1E3 Step 2

Add a class BackPainDialogFactory.cs with the following code

public class BackPainDialogFactory
{
    public const string DialogId = "back-pain";

    private readonly DialogAccessors _accessors;

    public BackPainDialogFactory(DialogAccessors accessors)
    {
        _accessors = accessors;
    }

    public Dialog Configure(DialogSet dialogSet)
    {
        RegisterPrompts(dialogSet);
        var steps = new WaterfallStep[]
        {
            ConfirmStartAsync,
            NextStepAsync,
        };
        var waterfallDialog = new WaterfallDialog(DialogId, steps);
        return waterfallDialog;
    }

    public async Task<DialogTurnResult> ConfirmStartAsync(
        WaterfallStepContext stepContext,
        CancellationToken cancellationToken)
    {
        // Provides a disclaimer about privacy and prompts the user to agree before continuing
        await stepContext.Context.SendActivityAsync(
            MessageFactory.Text(
                @"I'm about to ask you some questions to try to determine a course of care for your back pain.
Some of the questions will be very personal. While we do use the information you provide to improve our ability to help future patients, we will never try to identify individuals or share individual data with anyone."),
            cancellationToken);
        await Task.Delay(500, cancellationToken); // half-second between messages feels a little more natural
        await stepContext.Context.SendActivityAsync(MessageFactory.Text("We value your privacy above all other concerns."), cancellationToken);

        return await stepContext.PromptAsync(Prompts.ConfirmStart, new PromptOptions { Prompt = MessageFactory.Text("Do you wish to proceed?") }, cancellationToken);
    }

    public async Task<DialogTurnResult> NextStepAsync(
        WaterfallStepContext stepContext,
        CancellationToken cancellationToken)
    {
        var result = (bool)stepContext.Result;
        if (result)
        {
            await stepContext.Context.SendActivityAsync(
                MessageFactory.Text("Great. Let's get started!"),
                cancellationToken);
        }
        else
        {
            await stepContext.Context.SendActivityAsync(
                MessageFactory.Text("Okay, I understand."),
                cancellationToken);
        }

        return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
    }

    private void RegisterPrompts(DialogSet dialogSet)
    {
        dialogSet.Add(new ConfirmPrompt(Prompts.ConfirmStart));
    }

    private static class Prompts
    {
        public const string ConfirmStart = DialogId + "_confrim-start";
    }
}

L2M1E3 Step 3

Run the solution, and test in Bot Framework Emulator

Module 2: Stateful Waterfall Dialog

Exercise 1: Add State Object and Capture State

L2M2E1 Step 1

Under “Dialogs\BackPain”, create a file “BackPainDemographics.cs”. Add the following code

public class BackPainDemographics
{
    public string Age { get; set; }

    public string BiologicalSex { get; set; }

    public string CancerHistory { get; set; }

    public string PsychiatricCare { get; set; }

    public string HadPhysicalTherapy { get; set; }

    public string CognitiveBehavioralTherapy { get; set; }

    public string PreviousBackSurgery { get; set; }

    public string Fever { get; set; }

    public string FecalIncontinence { get; set; }

    public string OpioidUse { get; set; }

    public string LevelOfPain { get; set; }

    public string Race { get; set; }
}

L2M2E1 Step 2

In “DialogAccessors.cs”, add the following code

public static string BackPainDemographicsName { get; } = $"{nameof(DialogAccessors)}.{nameof(BackPainDemographics)}";
public IStatePropertyAccessor<BackPainDemographics> BackPainDemographics { get; set; }

L2M2E1 Step 3

In “Startup.cs”, find the code that initializes the DialogAccessors class, replace it with the following

var accessors = new DialogAccessors(conversationState)
{
    DialogState = conversationState.CreateProperty<DialogState>(DialogAccessors.DialogStateName),
    BackPainDemographics = conversationState.CreateProperty<BackPainDemographics>(DialogAccessors.BackPainDemographicsName),
};

L2M2E1 Step 4

In “BackPainDialogFactory.cs”

Add the following to the “Prompts” static class

public const string Age = DialogId + "_age";

Add the following to the “RegisterPrompts” method

dialogSet.Add(new NumberPrompt<int>(Prompts.Age));

Remove the method “NextStepAsync” and replace it with the following code

public async Task<DialogTurnResult> PromptForAgeAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    // If the user answered "yes", then we'll continue
    var proceed = (bool)stepContext.Result;
    if (proceed)
    {
        await stepContext.Context.SendActivityAsync(
            MessageFactory.Text("Okay. Let's get started."),
            cancellationToken);
        await Task.Delay(500, cancellationToken);
    }
    else
    {
        // user answered "no".
        await stepContext.Context.SendActivityAsync(
            MessageFactory.Text("I understand. I hope you feel better."),
            cancellationToken);
        return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
    }

    return await stepContext.PromptAsync(
        Prompts.Age,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("How old are you?"),
        },
        cancellationToken);
}

public async Task<DialogTurnResult> NextStepAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    // get the age from the last prompt
    var result = (int)stepContext.Result;

    // get the state (or create it if it is new)
    var state = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);

    // set the age in the state object
    state.Age = result.ToString(CultureInfo.InvariantCulture);

    // for now, we're going to end this step without a prompt so we can see the state persistence
    // at work in the next step
    return await stepContext.NextAsync(cancellationToken: cancellationToken);
}

public async Task<DialogTurnResult> FinalStepAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var state = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);

    // reflect the user's age back. This is retrieved from state
    await stepContext.Context.SendActivityAsync(MessageFactory.Text($"Your age is {state.Age}"), cancellationToken);
    return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
}

In the method “Configure”, replace the code that initializes “steps” with the following

var steps = new WaterfallStep[]
{
    ConfirmStartAsync,
    PromptForAgeAsync,
    NextStepAsync,
    FinalStepAsync,
};

L2M2E1 Step 5

Run the code and test it in Bot Framework Emulator

Exercise 2: Validate Dialog Input

L2M2E2 Step 1

In “BackPainDialogFactory.cs” add the following method

private async Task<bool> ValidateAgeAsync(PromptValidatorContext<int> context, CancellationToken cancellationToken)
{
    // Validates the age provided by the user. This will prevent invalid data.
    var value = context.Recognized.Value;
    if (value <= 0)
    {
        await context.Context.SendActivityAsync(
            MessageFactory.Text("You must be older than zero years old."),
            cancellationToken);
        return false;
    }

    // if the user is older than 120, make the age -1. This will cause them to exit out on the next step.
    if (value <= 120)
    {
        return true;
    }

    await context.Context.SendActivityAsync(
        MessageFactory.Text($"Congratulations for making it to {value} years of age. Unfortunately, our data set doesn't have the data necessary to help you."),
        cancellationToken);
    context.Recognized.Value = -1;

    return true;
}

L2M2E2 Step 2

In “NextStepAsync”, replace the first line of code with the following

// get the age from the last prompt
var result = (int)stepContext.Result;

if (result < 0)
{
    return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
}

L2M2E2 Step 3

Replace the Age prompt in “RegisterPrompts” with the following

dialogSet.Add(new NumberPrompt<int>(Prompts.Age, ValidateAgeAsync));

L2M2E2 Step 4

Run your code and test it in Bot Framework Emulator. Try entering an age of 0 or above 120.

Exercise 3: Finish Collecting Data

L2M2E3 Step 1

In the folder “Dialogs\BackPain” add a class BackPainTranslations.cs. Use the following code

public static class BackPainTranslations
{
    public static string YesNo(bool eval)
    {
        return eval ? "yes" : "no";
    }

    public static readonly List<Choice> PainLevelOptions = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }.Select(x => new Choice(x.ToString())).ToList();

    public static IDictionary<string, (string code, Choice choice)> BiologicalSexes => new Dictionary<string, (string code, Choice choice)>
    {
        {
            "Unspecified", ("unspecified", new Choice("Unspecified"))
        },
        {
            "Intersex", ("intersex", new Choice("Intersex"))
        },
        {
            "Female", ("female", new Choice("Female")
            {
                Synonyms = new List<string> { "Woman", "Girl" },
            })
        },
        {
            "Male", ("male", new Choice("Male")
            {
                Synonyms = new List<string> { "Man", "Boy" },
            })
        },
    };

    public static IDictionary<string, (string code, Choice choice)> Races => new Dictionary<string, (string code, Choice choice)>
    {
        {
            "African American", ("B", new Choice("African American")
            {
                Synonyms = new List<string> { "Black" },
            })
        },
        {
            "Caucasian", ("W", new Choice("Caucasian")
            {
                Synonyms = new List<string> { "White" },
            })
        },
        {
            "Asian", ("A", new Choice("Asian"))
        },
        {
            "Hispanic", ("H", new Choice("Hispanic")
            {
                Synonyms = new List<string> { "Latino", "Latina", "Mexican", "Mexican American" },
            })
        },
        {
            "Other", ("U", new Choice("Other"))
        },
    };
}

L2M2E3 Step 2

In the file “BackPainDialogFactory.cs”, replace the contents of the subclass “Prompts” with the following

public const string ConfirmStart = DialogId + "_confrim-start";
public const string Age = DialogId + "_age";
public const string BiologicalSex = DialogId + "_biological-sex";
public const string CancerHistory = DialogId + "_cancer-history";
public const string PsychCareHistory = DialogId + "_psych-care-history";
public const string PhysicalTherapyHistory = DialogId + "_physical-therapy-history";
public const string CognitiveBehavioralTherapyHistory = DialogId + "_cognitive-behavioral-therapy-history";
public const string PreviousBackSurgeryHistory = DialogId + "_previous-back-surgery-history";
public const string FeverHistory = DialogId + "_fever-history";
public const string FecalIncontinenceHistory = DialogId + "_fecal-incontinence-history";
public const string OpioidUse = DialogId + "_opioid-use";
public const string LevelOfPain = DialogId + "_level-of-pain";
public const string Race = DialogId + "_race";

L2M2E3 Step 3

In the file “BackPainDialogFactory.cs”, replace the contents of the method “RegisterPrompts” with the following

dialogSet
    .Add(new ConfirmPrompt(Prompts.ConfirmStart))
    .Add(new NumberPrompt<int>(Prompts.Age, ValidateAgeAsync))
    .Add(new ChoicePrompt(Prompts.BiologicalSex))
    .Add(new ConfirmPrompt(Prompts.CancerHistory))
    .Add(new ConfirmPrompt(Prompts.PsychCareHistory))
    .Add(new ConfirmPrompt(Prompts.PhysicalTherapyHistory))
    .Add(new ConfirmPrompt(Prompts.CognitiveBehavioralTherapyHistory))
    .Add(new ConfirmPrompt(Prompts.PreviousBackSurgeryHistory))
    .Add(new ConfirmPrompt(Prompts.FeverHistory))
    .Add(new ConfirmPrompt(Prompts.FecalIncontinenceHistory))
    .Add(new ConfirmPrompt(Prompts.OpioidUse))
    .Add(new ChoicePrompt(Prompts.LevelOfPain))
    .Add(new ChoicePrompt(Prompts.Race));

L2M2E3 Step 4

In the file “BackPainDialogFactory.cs”, delete the methods “NextStepAsync” and “FinalStepAsync” with the following

private async Task<DialogTurnResult> PromptForBiologicalSexAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);

    var age = (int)stepContext.Result;

    // if they were identified as too old during the age validation, we end the dialog here.
    if (age == -1)
    {
        return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
    }

    demographics.Age = age.ToString();

    return await stepContext.PromptAsync(
        Prompts.BiologicalSex,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Which option most closely approximates your biological sex."),
            Choices = BackPainTranslations.BiologicalSexes.Select(kv => kv.Value.choice).ToList(),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForCancerHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.BiologicalSex = BackPainTranslations
        .BiologicalSexes[((FoundChoice)stepContext.Result).Value]
        .code;
    return await stepContext.PromptAsync(
        Prompts.CancerHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Have you ever had cancer?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForPsychCareHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.CancerHistory = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.PsychCareHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Have you ever received psychiatric care?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForPhysicalTherapyHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    var psychiatricCare = (bool)stepContext.Result;
    demographics.PsychiatricCare = BackPainTranslations.YesNo(psychiatricCare);
    if (psychiatricCare)
    {
        await stepContext.Context.SendActivityAsync(MessageFactory.Text("I know that can be hard to admit some times, but sharing that information will definitely help us with the diagnosis."), cancellationToken);
        await Task.Delay(150, cancellationToken);
    }

    return await stepContext.PromptAsync(
        Prompts.PhysicalTherapyHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Have you ever had physical therapy?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForCognitiveBehavioralTherapyHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.HadPhysicalTherapy = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.CognitiveBehavioralTherapyHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Have you ever had cognitive behavioral therapy?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForPreviousBackSurgeryHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.CognitiveBehavioralTherapy = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.PreviousBackSurgeryHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Have you had back surgery before?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForFeverHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.PreviousBackSurgery = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.FeverHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Is or was your back pain associated with fever?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForFecalIncontinenceHistoryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.Fever = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.FecalIncontinenceHistory,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("I know the next question stinks, but I have to ask. Have you suffered from fecal incontinence in association with your back pain?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForOpioidUseAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.FecalIncontinence = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.OpioidUse,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("Are you, or have you recently been an opioid user?"),
        },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForLevelOfPainAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    demographics.OpioidUse = BackPainTranslations.YesNo((bool)stepContext.Result);
    return await stepContext.PromptAsync(
        Prompts.LevelOfPain,
        new PromptOptions
    {
        Prompt = MessageFactory.Text("How much pain are you in (1 is lowest, 10 is highest)?"),
        Choices = BackPainTranslations.PainLevelOptions,
    },
        cancellationToken);
}

private async Task<DialogTurnResult> PromptForRaceStepAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    BackPainDemographics demographics = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    FoundChoice choice = (FoundChoice)stepContext.Result;
    demographics.LevelOfPain = choice.Value;
    return await stepContext.PromptAsync(
        Prompts.Race,
        new PromptOptions
        {
            Prompt = MessageFactory.Text("What is your race?"),
            Choices = BackPainTranslations.Races.Select(kv => kv.Value.choice).ToList(),
        }, cancellationToken);
}

private async Task<DialogTurnResult> SummaryAsync(
    WaterfallStepContext stepContext,
    CancellationToken cancellationToken)
{
    var state = await _accessors.BackPainDemographics.GetAsync(
        stepContext.Context,
        () => new BackPainDemographics(),
        cancellationToken);
    var race = (FoundChoice)stepContext.Result;
    state.Race = BackPainTranslations.Races[race.Value].code;

    // reflect the user's answers back. This is retrieved from state
    var serialized = JsonConvert.SerializeObject(state);
    await stepContext.Context.SendActivityAsync(MessageFactory.Text(serialized), cancellationToken);
    return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);
}

L2M2E3 Step 5

In the file “BackPainDialogFactory.cs”, replace the contents of the method “Configure” with the following

RegisterPrompts(dialogSet);
var steps = new WaterfallStep[]
{
    ConfirmStartAsync,
    PromptForAgeAsync,
    PromptForBiologicalSexAsync,
    PromptForCancerHistoryAsync,
    PromptForPsychCareHistoryAsync,
    PromptForPhysicalTherapyHistoryAsync,
    PromptForCognitiveBehavioralTherapyHistoryAsync,
    PromptForPreviousBackSurgeryHistoryAsync,
    PromptForFeverHistoryAsync,
    PromptForFecalIncontinenceHistoryAsync,
    PromptForOpioidUseAsync,
    PromptForLevelOfPainAsync,
    PromptForRaceStepAsync,
    SummaryAsync,
};
var waterfallDialog = new WaterfallDialog(DialogId, steps);
return waterfallDialog;

L2M2E3 Step 6

Run the code and test it using the Bot Framework Emulator. Try various combinations of answers.

Exercise 4: Display Adaptive Card

L2M2E4 Step 1

Add the AdaptiveCards NuGet package to the project (Microsoft.AdaptiveCards)

L2M2E4 Step 2

Add the following code to the “ConfigureServices” method of “Startup.cs”

// This gives us access to the HTTP context. We can use this to determine the host address
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

L2M2E4 Step 3

Add the following extension method to “BackPainTranslations.cs”

public static List<Fact> ToFactList(this BackPainDemographics source)
{
    var race = Races.Single(r => r.Value.code == source.Race).Key;

    return new List<Fact>
    {
        new Fact("Age", source.Age, $"<s>age</s> {source.Age}"),
        new Fact("Biological Sex", source.BiologicalSex, $"<s>biological sex</s> {source.BiologicalSex}"),
        new Fact("History of Cancer", source.CancerHistory, $"<s>cancer history</s> {source.CancerHistory}"),
        new Fact("Psychiatric Care", source.PsychiatricCare, $"<s>psychiatric care</s> {source.PsychiatricCare}"),
        new Fact("Physical Therapy", source.HadPhysicalTherapy, $"<s>physical therapy</s> {source.HadPhysicalTherapy}"),
        new Fact("Cognitive Behavioral Therapy", source.CognitiveBehavioralTherapy, $"<s>cognitive behavioral therapy</s> {source.CognitiveBehavioralTherapy}"),
        new Fact("Back Surgery", source.PreviousBackSurgery, $"<s>back surgery</s> {source.PreviousBackSurgery}"),
        new Fact("Fever", source.Fever, $"<s>fever</s> {source.Fever}"),
        new Fact("Fecal Incontinence", source.FecalIncontinence, $"<s>fecal incontinence</s> {source.FecalIncontinence}"),
        new Fact("Opioid Use", source.OpioidUse, $"<s>opioid use</s> {source.OpioidUse}"),
        new Fact("Pain Level", source.LevelOfPain, $"<s>pain level</s> {source.LevelOfPain}"),
        new Fact("Race", race, $"<s>race</s> {race}"),
    };
}

L2M2E4 Step 4

Changes to the BackPainDialogFactory.cs file

Add IHttpContextAccessor httpAccessor to the constructor
Add a field private readonly string _hostAddress;
Add the following code to the constructor body

var request = httpAccessor.HttpContext.Request;
_hostAddress = $"{request.Scheme}://{request.Host}";

Add the following method

private async Task DisplaySummaryAsync(WaterfallStepContext stepContext, BackPainDemographics demographics, CancellationToken cancellationToken)
{
    var card = new AdaptiveCard
    {
        Speak = "<s>Submission Summary</s>. Please review for accuracy.",
        Body = new List<CardElement>
        {
            new TextBlock
            {
                Text = "Submission Summary",
                Size = TextSize.Large,
                Weight = TextWeight.Bolder,
            },
            new TextBlock
            {
                Text = "Please review for accuracy.",
            },
            new ColumnSet
            {
                Columns = new List<Column>
                {
                    new Column
                    {
                        Items = new List<CardElement>
                        {
                            new Image
                            {
                                Url = $"{_hostAddress}/images/check-mark.png",
                                AltText = "check mark",
                                Size = ImageSize.Medium,
                            },
                        },
                        Size = ColumnSize.Auto,
                    },
                    new Column
                    {
                        Items = new List<CardElement>
                        {
                            new FactSet
                            {
                                Facts = demographics.ToFactList(),
                            },
                        },
                        Size = ColumnSize.Stretch,
                    },
                },
            },
        },
    };

    var attachment = new Attachment
    {
        ContentType = AdaptiveCard.ContentType,
        Content = card,
    };
    await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(attachment), cancellationToken);
}

Replace the contents of SummaryAsync with the following code

var demographics = await _accessors.BackPainDemographics.GetAsync(
    stepContext.Context,
    () => new BackPainDemographics(),
    cancellationToken);
var race = (FoundChoice)stepContext.Result;
demographics.Race = BackPainTranslations.Races[race.Value].code;

await DisplaySummaryAsync(stepContext, demographics, cancellationToken);

return await stepContext.EndDialogAsync(cancellationToken: cancellationToken);

L2M2E4 Step 5

Run the code and test it using the Bot Framework Emulator

Exercise 5: Add Action to Card

L2M2E5 Step 1

Add a folder “Messages” to the project. Add the following two files:

PostBackData.cs

public class PostBackData<T>
{
    public PostBackData(string actionType, T data)
        => (ActionType, Data) = (actionType, data);

    public string ActionType { get; set; }

    public T Data { get; set; }
}

PostBackActions.cs

public static class PostBackActions
{
    public const string Default = "do-nothing";
    public const string SubmitBackPainData = "back-pain_continue";
    public const string StartBackPainSurvey = "back-pain_start";
}

L2M2E5 Step 2

Add the following static property to “BackPainTranslations.cs”

public static readonly List<Choice> ConfirmCompleteChoices = new List<Choice>
{
    new Choice("Continue")
    {
        Synonyms = new List<string> { "yes", "confirm", "affirmative" },
    },
    new Choice("Start Over")
    {
        Synonyms = new List<string> { "retry" },
    },
    new Choice("Cancel")
    {
        Synonyms = new List<string> { "quit", "exit", "bye" },
    },
};

L2M2E5 Step 3

In “DisplaySummaryAsync” in “BackPainDialogFactory.cs”, add the following “Actions” definition to the AdaptiveCard initializer.

Actions = new List<ActionBase>
{
    new SubmitAction
    {
        Title = "Continue",
        Data = new PostBackData<BackPainDemographics>(PostBackActions.SubmitBackPainData, demographics),
    },
    new SubmitAction
    {
        Title = "Start Over",
        Data = new PostBackData<string>(PostBackActions.StartBackPainSurvey, string.Empty),
    },
    new SubmitAction
    {
        Title = "Cancel",
        Data = new PostBackData<string>(PostBackActions.Default, string.Empty),
    },
},

L2M2E5 Step 4

In the “OnTurnAsync” method of “BackMeUp.cs”, replace the lines

var activityText = turnContext.Activity.Text.Trim().ToLowerInvariant();

// start the dialog. We'll do better when we integrate LUIS
if (new[] { "back pain", "start" }.Any(t => t == activityText))

in “BackMeUp.OnTurnAsync” with the following

var activityText = turnContext.Activity.Text?.Trim()?.ToLowerInvariant();

if (activityText == null)
{
    var jsonData = turnContext.Activity.Value as JObject;
    var postBackAction = jsonData?.GetValue("ActionType")?.Value<string>();
    if (postBackAction == null)
    {
        return;
    }

    switch (postBackAction)
    {
        case PostBackActions.StartBackPainSurvey:
            await dialogContext.BeginDialogAsync(
                BackPainDialogFactory.DialogId,
                cancellationToken: cancellationToken);
            break;
        case PostBackActions.SubmitBackPainData:
            var backPainDemographics = jsonData["Data"].ToObject<BackPainDemographics>();
            // todo we're doing this in Module 3
            Debugger.Break();
            break;
        case PostBackActions.Default:
            break;
        default:
            throw new InvalidOperationException($"The PostBack action type {postBackAction} was not recognized.");
    }
}
else if (new[] { "back pain", "start" }.Any(t => t == activityText))

L2M2E5 Step 5