瀑布对话框中的C＃Bot V4文本提示

Question

I need to add a question 'Did this help?' after getting the response from QnA and take the feedback from user. If there is no response for this and if the next input is a completely new query, the flow should restart from bot.cs

I tried using a textprompt, but when tested in emulator, bot doesn't wait for user input after the prompt.

Bot.cs

public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
    var activity = turnContext.Activity;
    var dc = await _dialogs.CreateContextAsync(turnContext);

    if (turnContext == null)
    {
        throw new ArgumentNullException(nameof(turnContext));
    }

    if (turnContext.Activity.Type == ActivityTypes.Message)
    {
        if (turnContext.Activity.Text != null)
        {                   
            var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken);                    
            var luisProperties = LuisEntities.FromLuisResults(luisResults);                  
            await _luisEntitiesAccessor.SetAsync(turnContext, luisProperties);                   
            var topScoringIntent = luisResults?.GetTopScoringIntent();
            var topIntent = topScoringIntent.Value.intent;

            switch (topIntent)
            {
                case NoneIntent:
                    await dc.BeginDialogAsync(QnADialog.Name);
                    break;
                case GreetingsIntent:
                    await dc.BeginDialogAsync(QnAGreetingsDialog.Name);                                       
                    break;
                case CredentialsIntent:
                    await dc.BeginDialogAsync(CredentialsDialog.Name);
                    break;
                case ContactusIntent:                                       
                    await dc.BeginDialogAsync(FeedbackDialog.Name);
                    break;
                case FeedbackIntent:
                    await dc.BeginDialogAsync(FeedbackDialog.Name);                                       
                    break;
                default:                                        
                    await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");                                       
                    break;
            }
        }
        else if (string.IsNullOrEmpty(turnContext.Activity.Text))
        {
            await HandleSubmitActionAsync(turnContext, userProfile);
        }
    }
    else if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate)
    {
        if (turnContext.Activity.MembersAdded != null)
        {
            await SendWelcomeMessageAsync(turnContext);
        }
    }
    else if (turnContext.Activity.Type == ActivityTypes.Event)
    {
        await SendWelcomeMessageAsync(turnContext);
    }
    else
    {
        await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected");
    }

    // Save the dialog state into the conversation state.
    await ConversationState.SaveChangesAsync(turnContext, false, cancellationToken);
}

QnADialog.cs - dialog in which I want the prompt to work

public class QnADialog : ComponentDialog
{        
    public const int QnaNumResults = 1;
    public const double QnaConfidenceThreshold = 0.5;

    public const string QnaConfiguration = "QnAFaqSubscriptionKey";
    private const string QnAFeedbackDialog = "qnaDialog";
    public const string Name = "QnA";
    public const string TextPrompt = "textPrompt";

    private readonly BotServices _services;
    private readonly IStatePropertyAccessor<UserProfile> _userProfileAccessor;

    Action<string, string, bool, int, int> updateQna;
    private int InvalidMessageCount = 0;
    string Query = string.Empty;
    List<int> qnaIdStorage;
    UserProfile userProfile = new UserProfile();

    public QnADialog(Action<string, string, bool, int, int> updateQna, bool isCollection, List<int> rotationTemStorage, BotServices services, UserProfile _userProfile, IStatePropertyAccessor<UserProfile> userProfileAccessor, int invalidMessageCount = 0, string dialogId = null)
        : base(Name)
    {
        _services = services ?? throw new ArgumentNullException(nameof(services));
        _userProfileAccessor = userProfileAccessor ?? throw new ArgumentNullException(nameof(userProfileAccessor));
        userProfile = _userProfile;

        this.updateQna = updateQna;
        this.InvalidMessageCount = invalidMessageCount;
        qnaIdStorage = rotationTemStorage;

        var waterfallSteps = new WaterfallStep[]
        {
            BeginStepAsync,
            FetchFAQResultStepAsync,
            FeedbackStepAsync,                                                                 
            FeedbackResponseStepAsync,                       

        };           

        AddDialog(new WaterfallDialog(QnAFeedbackDialog, waterfallSteps));            
        AddDialog(new TextPrompt("userFeed"));      
    }

    public async Task<DialogTurnResult> BeginStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken = default(CancellationToken))
    {
        var messageToForward = stepContext.Context.Activity;
        UserProfile.previousQuestion = messageToForward.Text;

        string[] supportList = { "HELP", "FEEDBACK", "SUPPORT", "ESCALATE", "AGENT" };

        if (messageToForward.Text == null || messageToForward.Text.ToLower() == "no")
        {
            await stepContext.Context.SendActivityAsync("Sorry, I was not able to help you.");
            return await stepContext.EndDialogAsync();
        }
        else if (messageToForward.Text == null || supportList.Any(x => x == messageToForward.Text.ToUpper()))
        {
            await stepContext.Context.SendActivityAsync("Please reach out to... ");
            return await stepContext.EndDialogAsync();
        }
        else
        {
            return await stepContext.NextAsync();
        }
    }

    private async Task<DialogTurnResult> FetchFAQResultStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        var message = stepContext.Context.Activity;

        var qnaResult = await FaqQnaMakerService.GetQnaResult(_services, stepContext, this.Query);
        var qnaIdColl = GetQnaIdColl(this.Query, qnaResult);
        int qnaPreviousId = 0;
        int qnaNewId = 0;

        if (qnaIdColl != null && qnaIdColl.Count > 1)
        {
            qnaIdColl = qnaIdColl.Distinct().OrderBy(x => x).ToList();
            //Compare the previous Qnaid collection and existing collection , if it is matching produce the result.
            var matchItem = qnaIdColl.Intersect(qnaIdStorage);

            if (matchItem.Count() == 0)
            {
                //If there is no previous collection Qna id then take the first item from the existing Qna collection
                qnaNewId = qnaIdColl.FirstOrDefault();
            }
            else
            {
                //If there any previous Qnaid that contain in the existing collection then pick the next value and generate a new qna result.
                qnaPreviousId = matchItem.FirstOrDefault();
                qnaNewId = GetNextRotationKey(qnaIdColl, qnaPreviousId);
            }

            //Create a new response based on selected new qna id.                
            qnaResult = new[] { qnaResult.Where(x => x.Id == qnaNewId).Single() };                
        }

        if (qnaResult.First().Answer.Length > 0)
        {
            if (qnaResult.First().Score > 0)
            {
                updateQna(this.Query, qnaResult.First().Answer, false, qnaPreviousId, qnaNewId);
                InvalidMessageCount = 0;
                var QuestionCollection = TextFormatter.FormattedQuestionColl(qnaResult.First().Answer);

                if (QuestionCollection != null)
                {
                    userProfile.IsAswerCollection = true;
                    updateQna(this.Query, qnaResult.First().Answer, true, qnaPreviousId, qnaNewId);
                    var replyMessage = stepContext.Context.Activity.CreateReply();
                    replyMessage.Attachments = new List<Attachment>() { AllAdaptiveCard.QnaAttachment(new Tuple<string, string[]>(QuestionCollection.Item2, QuestionCollection.Item3)) };

                    if (!string.IsNullOrEmpty(QuestionCollection.Item1))
                    {
                        await stepContext.Context.SendActivityAsync(QuestionCollection.Item1);
                    }

                    await stepContext.Context.SendActivityAsync(replyMessage);
                    return await stepContext.EndDialogAsync();                      
                }
                else
                {
                    await stepContext.Context.SendActivityAsync(qnaResult.First().Answer);
                }                   
            }             
            else
            {
                InvalidMessageCount++;
                return await stepContext.ContinueDialogAsync();                   
            }
        }          

        return await stepContext.NextAsync();
    }

    private async Task<DialogTurnResult> FeedbackStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        return await stepContext.PromptAsync("userFeed", new PromptOptions
        {
            Prompt = stepContext.Context.Activity.CreateReply("Did this help?")                
        });
    }

    private async Task<DialogTurnResult> FeedbackResponseStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
    {
        var message = stepContext.Context.Activity;
        var mesgActivity = message as Activity;

        string var = userProfile.qnaData;
        var qnaResultModel = new { InvalidMessageCount = 0, originalQueryText = string.Empty };
        NeedMoreInformation needmoreInfo = NeedMoreInformation.NotSelected;

        if (message != null && message.Text == null && message.Value != null)
        {
            dynamic value = mesgActivity.Value.ToString();
            UserReply response = JsonConvert.DeserializeObject<UserReply>(value);
            if (!string.IsNullOrEmpty(response.Reply))
            {
                mesgActivity.Text = response.Reply;
            }

        }

        //This if condition work only the user reply back to the question "Did this help?"
        if (userProfile.needMoreInformation == true && message?.Text?.ToLower() != "yes" && message?.Text?.ToLower() != "no")
        {
            //The response message pass to LUIS service to understand the intention of the conversation is “yes” or “no” 
            bool? moreInformationYes = await LUISService.GetResultAESChatBotYesNo(message?.Text);

            if (moreInformationYes != null && moreInformationYes == true)
            {
                //Once the LUIS understand the conversation change the original message to yes.
                message.Text = "yes";
                //needmoreInfo = NeedMoreInformation.Yes;
            }
            else if (moreInformationYes != null && moreInformationYes == false)
            {
                ////Once the LUIS understand the conversation change the original message to no.
                message.Text = "no";
                needmoreInfo = NeedMoreInformation.No;
            }
            else
            {
                needmoreInfo = NeedMoreInformation.None;
            }
        }

        if (userProfile.needMoreInformation == true && message?.Text?.ToLower() == "yes")
        {                   
            userProfile.qnaInvalidMessageCount = 0;
            userProfile.needMoreInformation = false;
            dynamic value = stepContext.Context.Activity.Value;
            var output = JsonConvert.DeserializeObject<UserReply>(stepContext.Context.Activity.Value.ToString());
            if (userProfile.feedbackCard == false)
            {
                var replyMessage = stepContext.Context.Activity.CreateReply();
                replyMessage.Attachments = new List<Attachment>() { AllAdaptiveCard.FeedbackAdapativecard() };
                await stepContext.Context.SendActivityAsync(replyMessage);
            }
            if (output.Reply != "yes")
            {
                await AdaptiveCardReplyAsync(_services, stepContext, userProfile);
            }                   
        }
        else if (userProfile.needMoreInformation == true && message?.Text?.ToLower() == "no")
        {
            userProfile.qnaInvalidMessageCount = 0;
            userProfile.needMoreInformation = false;
            dynamic value = stepContext.Context.Activity.Value;

            if (value.Type == "GetMoreContent")
            {
                await AdaptiveCardGetMoreContent(_services, stepContext, userProfile);
            }
            else if (value.Type == "GetHelpSubmit")
            {
                await AdaptiveCardReplyAsync(_services, stepContext, userProfile);
            }
            else if (userProfile.getMoreContentCard == false)
            {
                var replyMessage = stepContext.Context.Activity.CreateReply();
                replyMessage.Attachments = new List<Attachment>() { AllAdaptiveCard.GetMoreContent() };
                await stepContext.Context.SendActivityAsync(replyMessage);
            }

            // context.Wait(AdaptiveCardGetMoreContent);
        } 
        else
        { 
            await stepContext.BeginDialogAsync(nameof(Bot.cs));                    
        }

        return await stepContext.EndDialogAsync();
    }
}

After this prompt it should go to the next step as added in the waterfall steps but it does not. Any possible suggestions/help would be greatly appreciated. Thanks in advance!

Answer 1

Without seeing the code for your other steps inside the Waterfall such as BeginStepAsync and FetchFAQResultStepAsync it is difficult to give you an exact answer for your scenario.

How I would suggest you accomplish this is through the use of a message with suggested actions underneath this message, once either of this actions is clicked both options will disappear, thus removing the potential for multiple submissions by the same user for the same answer reply.

You have a couple of options here:

1) Use this dated sample that uses v3.9.0 of the Microsoft.Bot.Builder NuGet package, the meat of which is in the QnADialog and FeedbackDialog classes.

The important part is that the QnADialog implements QnAMakerDialog .

2) Right after where you send the reply to the user with the answer (inside FetchFAQResultsStepAsync I assume) you could add the following code:

var feedback = ((Activity)context.Activity).CreateReply("Did you find what you need?");

feedback.SuggestedActions = new SuggestedActions()
{
    Actions = new List<CardAction>()
    {
        new CardAction(){ Title = "Yes", Type=ActionTypes.PostBack, Value=$"yes-positive-feedback" },
        new CardAction(){ Title = "No", Type=ActionTypes.PostBack, Value=$"no-negative-feedback" }
    }
};

await context.PostAsync(feedback);

---

EDIT

Thank you for providing the full code for your QnADialog class, unfortunately I cannot run it locally because the implementations for methods such as GetQnaIdColl , GetNextRotationKey , TextFormatter.FormattedQuestionColl among other methods and classes that you call but haven't provided. Your code for prompting a user for a response looks right but it sounds like you're not even getting the feedback prompt to show, or you're getting the feedback prompt to show but you get stuck on there - can you confirm which it is? Have you tried stepping through the code to see which path it takes?

Another suggestion would be to separate out your QnA step and Feedback steps into separate Dialogs, I have proved and example feedback dialog below.

using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Dialogs;
using System.Threading;
using System.Threading.Tasks;

namespace ChatBot.VirtualAssistant.Dialogs
{
    public class RateAnswerDialog : ComponentDialog
    {
        public RateAnswerDialog()
            : base(nameof(RateAnswerDialog))
        {
            InitialDialogId = nameof(RateAnswerDialog);

            var askToRate = new WaterfallStep[]
            {
                AskRating,
                FinishDialog
            };

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

        private async Task<DialogTurnResult> AskRating(WaterfallStepContext sc, CancellationToken cancellationToken)
        {
            PromptOptions promptOptions = new PromptOptions
            {
                Prompt = MessageFactory.Text("Was this helpful?")
            };

            return await sc.PromptAsync(nameof(TextPrompt), promptOptions);
        }

        private async Task<DialogTurnResult> FinishDialog(WaterfallStepContext sc, CancellationToken cancellationToken)
        {
            return await sc.EndDialogAsync(sc);
        }

        protected override async Task<DialogTurnResult> EndComponentAsync(DialogContext outerDc, object context, CancellationToken cancellationToken)
        {
            var waterfallContext = (WaterfallStepContext)context;

            var userResponse = ((string)waterfallContext.Result).ToLowerInvariant();

            if (userResponse == "yes")
            {
                await waterfallContext.Context.SendActivityAsync("Thank you for your feedback");
            }
            else if (userResponse == "no")
            {
                await waterfallContext.Context.SendActivityAsync("Sorry I couldn't help you");
            }
            else
            {
                await waterfallContext.Context.SendActivityAsync("The valid answers are 'yes' or 'no'");

                // TODO reprompt if required
            }

            return await outerDc.EndDialogAsync();
        }
    }
}