首页 > 解决方案 > bot框架工作chatbot.Bot遇到错误

问题描述

机器人不去origin!=null。我尝试将起源作为一个单独的步骤,但仍然出现相同的错误。

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 yourSo.....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);
        }
    }
}

之后destination != null,机器人不去bookingdetails.origin= null。如果不可能,请指导任何其他方式来做到这一点,比如不同的步骤来获得不同的值。我试图这样做,但仍然会出现同样的问题。

标签: c#botframework

解决方案


推荐阅读