We Keep Coding

QnAMaker getting different results using GetAnswersRawAsync vs GetAnswersAsync in Botframework

When running a multi-turn conversation I am getting different results between GetAnswersRawAsync and GetAnswersAsync. GetAnswersRawAsync returns zero results about every 5th call where as GetAnswersAsync seems to always return. Is this a bug? What is the difference between the two? The documentation for both seems the same.
private async Task<DialogTurnResult> CallGenerateAnswerAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var qnaMakerOptions = new QnAMakerOptions
{
ScoreThreshold = DefaultThreshold,
Top = DefaultTopN,
Context = new QnARequestContext(),
QnAId = 0
};
var dialogOptions = GetDialogOptionsValue(stepContext);
// Getting options
if (dialogOptions.ContainsKey(QnAOptions))
{
qnaMakerOptions = dialogOptions[QnAOptions] as QnAMakerOptions;
qnaMakerOptions.ScoreThreshold = qnaMakerOptions?.ScoreThreshold ?? DefaultThreshold;
qnaMakerOptions.Top = DefaultTopN;
}
// Storing the context info
stepContext.Values[CurrentQuery] = stepContext.Context.Activity.Text;
// -Check if previous context is present, if yes then put it with the query
// -Check for id if query is present in reverse index.
if (!dialogOptions.ContainsKey(QnAContextData))
{
dialogOptions[QnAContextData] = new Dictionary<string, int>();
}
else
{
var previousContextData = dialogOptions[QnAContextData] as Dictionary<string, int>;
if (dialogOptions[PreviousQnAId] != null)
{
var previousQnAId = Convert.ToInt32(dialogOptions[PreviousQnAId]);
if (previousQnAId > 0)
{
qnaMakerOptions.Context = new QnARequestContext
{
PreviousQnAId = previousQnAId
};
qnaMakerOptions.QnAId = 0;
if (previousContextData.TryGetValue(stepContext.Context.Activity.Text.ToLower(), out var currentQnAId))
{
qnaMakerOptions.QnAId = currentQnAId;
}
}
}
}
var svc = _services.QnAMakerService;
// Does not return a result
var response = await svc.GetAnswersRawAsync(stepContext.Context, qnaMakerOptions).ConfigureAwait(false);
// Returns a result
var response2 = await svc.GetAnswersAsync(stepContext.Context, qnaMakerOptions).ConfigureAwait(false);
// Additional code removed for simplification
}

The difference between the 2 is that one returns the entire QnA Maker result whereas the other only returns the Answers property of the whole result.
GetAnswersAsync() - returns QueryResult.Answer
GetAnswersAsync(TurnContext, QnAMakerOptions) eventually calls the following GetAnswersAsync overload
public async Task<QueryResult[]> GetAnswersAsync(
ITurnContext turnContext,
QnAMakerOptions options,
Dictionary<string, string> telemetryProperties,
Dictionary<string, double> telemetryMetrics = null)
{
var result = await GetAnswersRawAsync(turnContext, options, telemetryProperties, telemetryMetrics).ConfigureAwait(false);
return result.Answers;
}
Notice how it just calls GetAnswersRawAsync and from those results, it only returns its answer.
vs.
GetAnswersRawAsync() - returns entire QueryResult
public async Task<QueryResults> GetAnswersRawAsync(
ITurnContext turnContext,
QnAMakerOptions options,
Dictionary<string, string> telemetryProperties = null,
Dictionary<string, double> telemetryMetrics = null)
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (turnContext.Activity == null)
{
throw new ArgumentException($"The {nameof(turnContext.Activity)} property for {nameof(turnContext)} can't be null.", nameof(turnContext));
}
var messageActivity = turnContext.Activity.AsMessageActivity();
if (messageActivity == null)
{
throw new ArgumentException("Activity type is not a message");
}
if (string.IsNullOrEmpty(turnContext.Activity.Text))
{
throw new ArgumentException("Null or empty text");
}
var result = await this._generateAnswerHelper.GetAnswersRawAsync(turnContext, messageActivity, options).ConfigureAwait(false);
await OnQnaResultsAsync(result.Answers, turnContext, telemetryProperties, telemetryMetrics, CancellationToken.None).ConfigureAwait(false);
return result;
}
You can see the source code in the botbuidler-dotnet repo here.

How call a step of waterfall on a particular condition?

I have a bot made using c# and v4 framework. It always asks user do they want to ask more questions from bot with a yes/no prompt:
i want that on "clicking on a particular condition of waterfall should be called" otherwise on all other conditions that step of waterfall should skipped and bot should function normally.I am also adding code just for reference.
The code of main dialog
public MainDialog(ILogger<MainDialog> logger, IBotServices botServices, UserState userState) :
base(nameof(MainDialog))
{ _botServices = botServices;// ?? throw new System.ArgumentNullException(nameof(botServices));
_logger = logger;
_userState = userState;
AddDialog(new ProductIssue($"{nameof(MainDialog)}.fromMain", _botServices, _userState));
AddDialog(new ProductIssue($"{nameof(Confirm)}.fromConfirm", _botServices, _userState));
AddDialog(new ProductIssue($"{ nameof(Resolution)}.resolution", _botServices, _userState));
AddDialog(new PurchaseFlow(_userState));
AddDialog(new Resolution( _userState));
AddDialog(new Confirm(_botServices,_userState));
AddDialog(new ChoicePrompt($"{nameof(MainDialog)}.issue"));
AddDialog(new TextPrompt($"{nameof(MainDialog)}.callDialog"));
AddDialog(new TextPrompt($"{nameof(MainDialog)}.number", ValidationAsync));
AddDialog(new WaterfallDialog($"{nameof(MainDialog)}.mainFlow", new WaterfallStep[]
{
MoblieNumberAsync,
ChoiceCardStepAsync,
ShowCardStepAsync,
CallingDialogsAsync
}));
AddDialog(new TextPrompt(nameof(TextPrompt)));
InitialDialogId = $"{nameof(MainDialog)}.mainFlow";
}
private async Task<DialogTurnResult> MoblieNumberAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
stepContext.Values[UserInfo] = new UserInput();
var options = new PromptOptions()
{
Prompt = MessageFactory.Text("Kindly enter your 10 digit mobile number without any spaces, dashes and country code. We will be sending an OTP later to this number "),
RetryPrompt = MessageFactory.Text("Incorrect mobile number entered. Please only enter the 10 digits of your mobile without any spaces, dashes and country code.")
};
return await stepContext.PromptAsync($"{nameof(MainDialog)}.number", options, cancellationToken);
}
private async Task<DialogTurnResult> ChoiceCardStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var userStateAccessors = _userState.CreateProperty<UserInput>(nameof(UserInput));
var userinfo = await userStateAccessors.GetAsync(stepContext.Context, () => new UserInput());
userinfo.phone_no = (string)stepContext.Result;
CustomerDetails customerDetails = new CustomerDetails();
//API-Get Customer Details from CRM
try
{
BotAPIBLL botApiBLL = new BotAPIBLL();
var response = botApiBLL.GetCustomerDetail(stepContext.Context.Activity.Text);
customerDetails = JsonConvert.DeserializeObject<CustomerDetails>(response);
}
catch(Exception ex)
{
}
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Fetching your details from our systems. This may take a moment"), cancellationToken);
if (customerDetails.D != null && !string.IsNullOrEmpty(customerDetails.D.TelNumber) && !string.IsNullOrEmpty(customerDetails.D.NameFirst))
{
DbConnection dbConnection = new DbConnection();
dbConnection.SaveCutomerInfo(customerDetails);
userinfo.Name = customerDetails.D.NameFirst;
var options = new PromptOptions()
{
Prompt = MessageFactory.Text("Welcome " + customerDetails.D.NameFirst + ", How can we serve you ? "),
RetryPrompt = MessageFactory.Text("That was not a valid choice, please select a option between 1 to 5."),
Choices = GetChoices(),
Style = ListStyle.HeroCard
};
return await stepContext.PromptAsync($"{nameof(MainDialog)}.issue", options, cancellationToken);
}
else
{
var options = new PromptOptions()
{
Prompt = MessageFactory.Text("Welcome Guest_" + userinfo.phone_no + ", How can we serve you ? "),
RetryPrompt = MessageFactory.Text("That was not a valid choice, please select a option between 1 to 5."),
Choices = GetChoices(),
Style = ListStyle.HeroCard
};
return await stepContext.PromptAsync($"{nameof(MainDialog)}.issue", options, cancellationToken);
}
}
private async Task<DialogTurnResult> ShowCardStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var userinfo = (UserInput)stepContext.Values[UserInfo];
userinfo.choiceselected = ((FoundChoice)stepContext.Result).Value;
var attachments = new List<Attachment>();
var reply = MessageFactory.Text("");
var user_choice = ((FoundChoice)stepContext.Result).Value;
switch (user_choice)
{
case "Product issue":
reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment3());
break;
case "Register Product":
reply.Attachments.Add(Cards.GetHeroCard1().ToAttachment());
break;
case "Online Purchase":
return await stepContext.BeginDialogAsync(nameof(PurchaseFlow), null, cancellationToken);
case "Customer Grivance":
reply.Attachments.Add(Cards.GetHeroCard3().ToAttachment());
break;
case "Order Status":
reply.Attachments.Add(Cards.GetHeroCard6().ToAttachment());
break;
default:
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment3());
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments.Add(Cards.GetHeroCard1().ToAttachment());
break;
}
if (user_choice == "Register Product" || user_choice == "Online Purchase" || user_choice == "Customer Grivance")
{
await stepContext.Context.SendActivityAsync(reply, cancellationToken);
Random r = new Random();
var validationcard = Cards.CreateAdaptiveCardAttachment2(_cards[r.Next(_cards.Length)]);
//var feedbackcard = Cards.CustomerFeedback();
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(validationcard), cancellationToken);
//await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(feedbackcard), cancellationToken);
var accessor = _userState.CreateProperty<UserInput>(nameof(UserInput));
await accessor.SetAsync(stepContext.Context, userinfo, cancellationToken);
return await stepContext.EndDialogAsync(null, cancellationToken);
}
else
{
var options2 = new PromptOptions() { Prompt = reply, RetryPrompt = MessageFactory.Text("Retry") };
return await stepContext.PromptAsync($"{nameof(MainDialog)}.callDialog", options2, cancellationToken);
}
}
private async Task<DialogTurnResult> CallingDialogsAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use.
var recognizerResult = await _botServices.Dispatch.RecognizeAsync(stepContext.Context, cancellationToken);
// Top intent tell us which cognitive service to use.
var topIntent = recognizerResult.GetTopScoringIntent();
switch (topIntent.intent)
{
case "Mainissue":
return await stepContext.BeginDialogAsync($"{nameof(MainDialog)}.fromMain", stepContext.Values[UserInfo], cancellationToken);
case "ConfirmIntent":
return await stepContext.BeginDialogAsync(nameof(Confirm), null, cancellationToken);
case "EndBotIntent":
return await stepContext.CancelAllDialogsAsync(true, null, null, cancellationToken);
case "InverterData":
await ProcessSampleQnAAsync(stepContext, cancellationToken);
break;
default:
await stepContext.Context.SendActivityAsync(MessageFactory.Text($"I'm sorry I don't know what you mean."), cancellationToken);
break;
}
return await stepContext.EndDialogAsync(null, cancellationToken);
}
private IList<Choice> GetChoices()
{
var cardOptions = new List<Choice>()
{
new Choice() { Value = "Product issue", Synonyms = new List<string>() { "adaptive" } },
new Choice() { Value = "Register Product", Synonyms = new List<string>() { "hero" } },
new Choice() { Value = "Online Purchase", Synonyms = new List<string>() { "hero" } },
new Choice() { Value = "Customer Grivance", Synonyms = new List<string>() { "hero" } },
new Choice() { Value = "Order Status", Synonyms = new List<string>() { "hero" } }
};
return cardOptions;
}
private Task<bool> ValidationAsync(PromptValidatorContext<string> promptContext, CancellationToken cancellationToken)
{
string value = (string)promptContext.Context.Activity.Text;
if (Regex.IsMatch(value, "^[0-9]{10}$"))
{
return Task.FromResult(true);
}
else
{
return Task.FromResult(false);
}
}
private async Task ProcessSampleQnAAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
_logger.LogInformation("ProcessSampleQnAAsync");
var results = await _botServices.SampleQnA.GetAnswersAsync(stepContext.Context);
if (results.Any())
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text(results.First().Answer), cancellationToken);
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Sorry, could not find an answer in the Q and A system."), cancellationToken);
}
}
}

You can skip the step by evaluating the condition and calling NextAsync, like this:
if (condition)
{
await stepContext.NextAsync(stepContext.Result, cancellationToken);
}
// otherwise process this step
The NextAsync immediately passes control to the next step with whatever you used as the 1st parameter. In this case, I used stepContext.Result, which is the result of the previous step that will be passed to the next step.

QnA call fails in Bot Framework, both locally and deployed

I've been trying to build a bot that uses QnA to anser the user based on categories.
I've managed to connect to QnA correctly and get the first level prompted to the user, however, the problem appears when I try to send to QnA another response from the user.
Here's the dialog that runs smoothly on it's first request.
private async Task<DialogTurnResult> InicioRRHHDialog(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
string intentForQna = IntentEnum.DISPATCH_RRHH;
var castContextForQna = (WaterfallStepContext)stepContext.Parent;
var contextForNextStep = stepContext.Context;
await GetQnaConnection(castContextForQna, intentForQna);
return await stepContext.NextAsync(contextForNextStep, cancellationToken);
}
This is the GetQnaConnection being called.
private async Task GetQnaConnection(WaterfallStepContext stepContext, string intent)
{
servicioQNA = new QnAMakerService(this._qnaService.Url, _qnaRRHHkbId, this._qnaService.QnaEndPointKey);
var mensaje = await servicioQNA.QueryQnAServiceAsync(intent, null);
await ShowResults(stepContext, mensaje);
}
And lastly the ShowResults method that I use to send the activity back to the user.
private static async Task ShowResults(WaterfallStepContext stepContext, QnAResult[] mensaje)
{
Activity outputActivity = null;
QnABotState newState = null;
var qnaAnswer = mensaje[0].Answer;
var prompts = mensaje[0].Context?.Prompts;
if (prompts == null || prompts.Length < 1)
outputActivity = MessageFactory.Text(qnaAnswer);
else
{
newState = new QnABotState
{
PreviousQnaId = mensaje[0].Id,
PreviousUserQuery = stepContext.Result.ToString()
};
outputActivity = CardHelper.GetHeroCard(qnaAnswer, prompts);
}
var outputs = new Activity[] { outputActivity };
foreach (var activity in outputs)
await stepContext.Context.SendActivityAsync(activity).ConfigureAwait(false);
}
Am I handling the Qna connection correctly?

bot frame work chatbot.Bot encounters bug

A bot doesn't go to origin!=null. I have tried taking origin as a separate step, still the same bug occurs.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Schema;
using Microsoft.Extensions.Logging;
using Microsoft.Recognizers.Text.DataTypes.TimexExpression;
using Newtonsoft.Json;
namespace Microsoft.BotBuilderSamples.Dialogs
{
public class MainDialog : ComponentDialog
{
private readonly FlightBookingRecognizer _luisRecognizer;
protected readonly ILogger Logger;
// Dependency injection uses this constructor to instantiate MainDialog
public MainDialog(FlightBookingRecognizer luisRecognizer, BookingDialog bookingDialog, ILogger<MainDialog> logger)
: base(nameof(MainDialog))
{
_luisRecognizer = luisRecognizer;
Logger = logger;
AddDialog(new TextPrompt(nameof(TextPrompt)));
AddDialog(bookingDialog);
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
IntroStepAsync,
ActStepAsync,
OriginStepAsync,
OriginConfirmAsync,
FinalStepAsync,
}));
// The initial child Dialog to run.
InitialDialogId = nameof(WaterfallDialog);
}
private const string DestinationStepMsgText = "Where would you like to travel to?";
private const string OriginStepMsgText = "Where are you traveling from?";
private async Task<DialogTurnResult> IntroStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the appsettings.json file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return await stepContext.NextAsync(null, cancellationToken);
}
// Use the text provided in FinalStepAsync or the default if it is the first time.
var messageText = stepContext.Options?.ToString() ?? "What can I help you with today?\nSay something like \"Book a flight from Paris to Berlin on March 22, 2020\"";
var promptMessage = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput);
return await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken);
}
private async Task<DialogTurnResult> ActStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
// LUIS is not configured, we just run the BookingDialog path with an empty BookingDetailsInstance.
return await stepContext.BeginDialogAsync(nameof(BookingDialog), new BookingDetails(), cancellationToken);
}
// Call LUIS and gather any potential booking details. (Note the TurnContext has the response to the prompt.)
var luisResult = await _luisRecognizer.RecognizeAsync<FlightBooking>(stepContext.Context, cancellationToken);
switch (luisResult.TopIntent().intent)
{
//case FlightBooking.Intent.BookFlight:
// await ShowWarningForUnsupportedCities(stepContext.Context, luisResult, cancellationToken);
// // Initialize BookingDetails with any entities we may have found in the response.
// //var bookingDetails = new BookingDetails()
// //{
// // // Get destination and origin from the composite entities arrays.
// // Destination = luisResult.ToEntities.Airport,
// // Origin = luisResult.FromEntities.Airport,
// // TravelDate = luisResult.TravelDate,
// //};
// return await stepContext.BeginDialogAsync(nameof(BookingDialog), bookingDetails, cancellationToken);
case FlightBooking.Intent.TravellerDeatail:
//await ShowWarningForUnsupportedCities(stepContext.Context, luisResult, cancellationToken);
// Initialize BookingDetails with any entities we may have found in the response.
var bookingDetails = new BookingDetails()
{
// Get destination and origin from the composite entities arrays.
Destination = luisResult.DestinationEntities.Destination,
Origin = luisResult.OriginEntities.Origin,
TravelDate = luisResult.TravelDate,
};
if (bookingDetails.Destination == null)
{
var messageText1 = stepContext.Options?.ToString() ?? DestinationStepMsgText;
var promptMessage1 = MessageFactory.Text(messageText1, messageText1, InputHints.ExpectingInput);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage1 }, cancellationToken);
var promptMessage3 = "";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage3, cancellationToken);
}
if (bookingDetails.Destination != null)
{
string[] SplitDest;
string combined = "";
string collection = "";
string PreDest = bookingDetails.Destination;
string ConDest = bookingDetails.ConDestination;
try
{
if (PreDest.Length != 3)
{
var keyword = PreDest;
string[] strCity = File.ReadAllText(#"D:\Ravvise project\Attarbot2-src\AdditionalIN\Airports.txt").Split('$');
foreach (string str in strCity)
{
if (str.IndexOf(keyword, StringComparison.CurrentCultureIgnoreCase) >= 0)
{
combined += str + '$';
}
}
}
SplitDest = combined.Split("$");
foreach (var prepoll in SplitDest)
{
if (SplitDest.Length == 1)
{
ConDest = SplitDest[0];
ConDest = SplitDest[0].Split("[")[1].Replace("]", "");
}
else if (SplitDest.Length > 1)
{
string DestBody = File.ReadAllText(#"D:\Ravvise project\Attarbot2-src\AdditionalIN\DestBody.txt");
string strTemp = "";
collection = "";
foreach (string city in SplitDest)
{
if (city != "")
{
ConDest = city.Split("[")[1].Replace("]", "");
strTemp = DestBody.Replace("{ZZZ}", city);
strTemp = strTemp.Replace("{YYY}", ConDest);
collection += strTemp;
}
}
collection = collection.TrimEnd(',');
string DestTemplate = File.ReadAllText(#"D:\Ravvise project\Attarbot2-src\AdditionalIN\DestTemplate.txt");
DestTemplate = DestTemplate.Replace("{XXX}", collection);
var cardAttachment = new Attachment()
{
ContentType = "application/vnd.microsoft.card.adaptive",
Content = JsonConvert.DeserializeObject(DestTemplate.ToString()),
};
var opts = new PromptOptions
{
Prompt = new Activity
{
Attachments = new List<Attachment>() { cardAttachment },
Type = ActivityTypes.Message,
Text = "Kindly select any Combinations from below.", // You can comment this out if you don't want to display any text. Still works.
}
};
// Display a Text Prompt and wait for input
return await stepContext.PromptAsync(nameof(TextPrompt), opts);
}
}
}
catch (Exception ex) { }
return await stepContext.ContinueDialogAsync();
}
if (bookingDetails.Origin == null)
{
var messageText1 = stepContext.Options?.ToString() ?? "Wow 😍😍😍😍😍😍😍😍" + bookingDetails.Destination + " is a great place to explore.Kindly tell your Origin.";
var promptMessage1 = MessageFactory.Text(messageText1, messageText1, InputHints.ExpectingInput);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage1 }, cancellationToken);
var promptMessage3 = "";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage3, cancellationToken);
}
var promptMessage5 = "";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage5, cancellationToken);
case FlightBooking.Intent.Greeting:
var messageText = stepContext.Options?.ToString() ?? "Gretings Mate!!!!!!😉😉😉I wink cus I wanna help you with your😃😃😃😃😃So.....Kindly tell me your travel deatails.";
var promptMessage = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken);
var promptMessage2 = "";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage2, cancellationToken);
// Run the BookingDialog giving it whatever details we have from the LUIS call, it will fill out the remainder.
case FlightBooking.Intent.GetWeather:
// We haven't implemented the GetWeatherDialog so we just display a TODO message.
var getWeatherMessageText = "TODO: get weather flow here";
var getWeatherMessage = MessageFactory.Text(getWeatherMessageText, getWeatherMessageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(getWeatherMessage, cancellationToken);
break;
default:
// Catch all for unhandled intents
var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try asking in a different way (intent was {luisResult.TopIntent().intent})";
var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
break;
}
return await stepContext.NextAsync(null, cancellationToken);
}
// Shows a warning if the requested From or To cities are recognized as entities but they are not in the Airport entity list.
// In some cases LUIS will recognize the From and To composite entities as a valid cities but the From and To Airport values
// will be empty if those entity values can't be mapped to a canonical item in the Airport.
private async Task<DialogTurnResult> OriginStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var bookingDetails = (BookingDetails)stepContext.Options;
bookingDetails.ConDestination = (string)stepContext.Result;
if (bookingDetails.Origin == null)
{
var messageText1 = stepContext.Options?.ToString() ?? "Wow 😍😍😍😍😍😍😍😍" + bookingDetails.Destination + " is a great place to explore.Kindly tell your Origin.";
var promptMessage1 = MessageFactory.Text(messageText1, messageText1, InputHints.ExpectingInput);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage1 }, cancellationToken);
}
var promptMessage3 = "";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage3, cancellationToken);
}
private async Task<DialogTurnResult> OriginConfirmAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
string[] SplitOrigin;
string combined = "";
string collection = "";
string PConOrigin = "";
var bookingDetails = (BookingDetails)stepContext.Options;
bookingDetails.Origin = (string)stepContext.Result;
string PreOrigin = bookingDetails.Origin;
string ConOrigin = bookingDetails.ConOrigin;
try
{
if (PreOrigin.Length != 3)
{
var keyword = PreOrigin;
string[] strCity = File.ReadAllText("E:/Airports.txt").Split('$');
foreach (string str in strCity)
{
if (str.IndexOf(keyword, StringComparison.CurrentCultureIgnoreCase) >= 0)
{
combined += str + '$';
}
}
}
SplitOrigin = combined.Split("$");
foreach (var prepoll in SplitOrigin)
{
if (SplitOrigin.Length == 1)
{
ConOrigin = SplitOrigin[0];
ConOrigin = SplitOrigin[0].Split("[")[1].Replace("]", "");
}
else if (SplitOrigin.Length > 1)
{
string DestBody = File.ReadAllText("E:/DestBody.txt");
string strTemp = "";
collection = "";
foreach (string city in SplitOrigin)
{
if (city != "")
{
ConOrigin = city.Split("[")[1].Replace("]", "");
strTemp = DestBody.Replace("{ZZZ}", city);
strTemp = strTemp.Replace("{YYY}", ConOrigin);
collection += strTemp;
}
}
collection = collection.TrimEnd(',');
string DestTemplate = File.ReadAllText("E:/DestTemplate.txt");
DestTemplate = DestTemplate.Replace("{XXX}", collection);
var cardAttachment = new Attachment()
{
ContentType = "application/vnd.microsoft.card.adaptive",
Content = JsonConvert.DeserializeObject(DestTemplate.ToString()),
};
var opts = new PromptOptions
{
Prompt = new Activity
{
Attachments = new List<Attachment>() { cardAttachment },
Type = ActivityTypes.Message,
Text = "Kindly select any Combinations from below.", // You can comment this out if you don't want to display any text. Still works.
}
};
// Display a Text Prompt and wait for input
return await stepContext.PromptAsync(nameof(TextPrompt), opts);
}
}
}
catch (Exception ex) { }
return await stepContext.NextAsync(bookingDetails.ConOrigin, cancellationToken);
}
private async Task<DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// If the child dialog ("BookingDialog") was cancelled, the user failed to confirm or if the intent wasn't BookFlight
// the Result here will be null.
if (stepContext.Result is BookingDetails result)
{
// Now we have all the booking details call the booking service.
// If the call to the booking service was successful tell the user.
var timeProperty = new TimexProperty(result.TravelDate);
var travelDateMsg = timeProperty.ToNaturalLanguage(DateTime.Now);
var messageText = $"I have you booked to {result.Destination} from {result.Origin} on {travelDateMsg}";
var message = MessageFactory.Text(messageText, messageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(message, cancellationToken);
}
// Restart the main dialog with a different message the second time around
var promptMessage = "What else can I do for you?";
return await stepContext.ReplaceDialogAsync(InitialDialogId, promptMessage, cancellationToken);
}
}
}
After destination != null, bot doesn't go to bookingdetails.origin= null. If it is not possible please guide any other way to do it like different steps to get different values. I tried to do it but still, the same problem occurs.

Botframework v4: Uploading image to the bot in another class

I have this code in OnTurnAsync() in the main bot class that let the user upload image and saved it locally and its working fine.
But how can i do this if i want to do it in a different class like a MainDialog class?
Update: I manage to do it by the code below. But it is accepting everything, how can i do a validation that accepts only images?
Update: Answer below.
public class MainDialog : ComponentDialog
{
private const string InitialId = "mainDialog";
private const string TEXTPROMPT = "textPrompt";
private const string ATTACHPROMPT = "attachPrompt";
public MainDialog(string dialogId)
: base(dialogId)
{
WaterfallStep[] waterfallSteps = new WaterfallStep[]
{
FirstStepAsync,
SecondStepAsync,
};
AddDialog(new WaterfallDialog(InitialId, waterfallSteps));
AddDialog(new AttachmentPrompt(ATTACHPROMPT));
}
private static async Task<DialogTurnResult> FirstStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken = default(CancellationToken))
{
return await stepContext.PromptAsync(
ATTACHPROMPT,
new PromptOptions
{
Prompt = MessageFactory.Text($"upload photo."),
RetryPrompt = MessageFactory.Text($"upload photo pls."),
});
}
private static async Task<DialogTurnResult> SecondStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken = default(CancellationToken))
{
var activity = stepContext.Context.Activity;
if (activity.Attachments != null && activity.Attachments.Any())
{
foreach (var file in stepContext.Context.Activity.Attachments)
{
var remoteFileUrl = file.ContentUrl;
var localFileName = Path.Combine(Path.GetTempPath(), file.Name);
using (var webClient = new WebClient())
{
webClient.DownloadFile(remoteFileUrl, localFileName);
}
await stepContext.Context.SendActivityAsync($"Attachment {stepContext.Context.Activity.Attachments[0].Name} has been received and saved to {localFileName}.");
}
}
return await stepContext.EndDialogAsync();
}
Managed to do it with this code.
var activity = stepContext.Context.Activity;
if (activity.Attachments != null && activity.Attachments.Any())
{
foreach (var file in stepContext.Context.Activity.Attachments)
{
if (file.ContentType.EndsWith("/jpg") || file.ContentType.EndsWith("/png") || file.ContentType.EndsWith("/bmp") || file.ContentType.EndsWith("/jpe"))
{
var remoteFileUrl = file.ContentUrl;
var localFileName = Path.Combine(Path.GetTempPath(), file.Name);
using (var webClient = new WebClient())
{
webClient.DownloadFile(remoteFileUrl, localFileName);
}
await stepContext.Context.SendActivityAsync($"Attachment {stepContext.Context.Activity.Attachments[0].Name} has been received and saved to {localFileName}.");
return await stepContext.NextAsync();
}
else
{
await stepContext.Context.SendActivityAsync($"Attachment {file.Name} is not an image, it is {file.ContentType}.");
// restart the dialog from top
return await stepContext.ReplaceDialogAsync(InitialId);
}
}
}

Like Nicolas R said, you could do some basic validation like this:
foreach (var file in activity.Attachments)
{
if (file.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
await turnContext.SendActivityAsync($"Attachment {file.Name} is an image of type {file.ContentType}.");
}
else
{
await turnContext.SendActivityAsync($"Attachment {file.Name} is not an image, it is {file.ContentType}.");
}
}
This will of course allow any attachment with a content type that starts with "image/". You might not want to allow any content type that starts with "image/", in which case you'd want to make a list of accepted types like "image/png" and "image/jpeg". You might also consider checking the file extension (to see if it's ".png" or ".jpg" etc.)