public static async Task <DialogTurnResult> BuildNumberPrompt(this DialogContext dc, string message = "Please confirm: Yes to proceed or No to cancel", CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await dc.PromptAsync(nameof(NumberPrompt <int>), new PromptOptions
     {
         Prompt = MessageFactory.Text(message)
     }, cancellationToken));
 }
示例#2
0
 protected override Task <DialogTurnResult> OnBeginDialogAsync(DialogContext innerDc, object options, CancellationToken cancellationToken = default)
 {
     return(innerDc.PromptAsync(nameof(TextPrompt), new PromptOptions()
     {
         Prompt = MessageFactory.Text("Wie viel rekursionen sollen erstellt werden?")
     }));
 }
        protected override async Task OnStartAsync(DialogContext dc, CancellationToken cancellationToken = default(CancellationToken))
        {
            var onboardingState = await _onboardingState.GetAsync(dc.Context, () => new OnboardingState());

            if (string.IsNullOrEmpty(onboardingState.Name) || onboardingState.Number == 0)
            {
                await _responder.ReplyWith(dc.Context, MainResponses.ResponseIds.NewUserGreeting);

                await dc.BeginDialogAsync(nameof(OnboardingDialog));
            }
            else
            {
                var attachement = GetGreetingCard(onboardingState.Name);
                var opts        = new PromptOptions
                {
                    Prompt = new Activity
                    {
                        Type        = ActivityTypes.Message,
                        Attachments = new List <Attachment> {
                            attachement
                        },
                    },
                };
                await dc.PromptAsync("GreetingPrompt", opts);
            }
        }
 public static async Task <DialogTurnResult> BuildChoicePrompt(this DialogContext dc, string message, string[] choicelist, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await dc.PromptAsync(nameof(ChoicePrompt), new PromptOptions
     {
         Prompt = MessageFactory.Text(message),
         Choices = ChoiceFactory.ToChoices(choicelist.ToList <string>()),
     }, cancellationToken));
 }
示例#5
0
        public async Task <DialogTurnResult> ToppingStep(DialogContext dc, CancellationToken cancellationToken = default)
        {
            dc.ActiveDialog.State["stepID"] = "ToppingStep";

            var toppingMessage = MessageFactory.Text("What topping would you like", "What topping would you like", InputHints.ExpectingInput);

            return(await dc.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = toppingMessage }, cancellationToken));
        }
示例#6
0
        public async Task <DialogTurnResult> DateStep(DialogContext dc, CancellationToken cancellationToken = default)
        {
            dc.ActiveDialog.State["stepID"] = "DateStep";

            var cheeseMessage = MessageFactory.Text("When would you like to take the fligh", "When would you like to take the fligh", InputHints.ExpectingInput);

            return(await dc.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = cheeseMessage }, cancellationToken));
        }
        private static async Task <DialogTurnResult> Waterfall2_Step1(DialogContext dc, WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            await dc.Context.SendActivityAsync("step1");

            return(await dc.PromptAsync("number", new PromptOptions {
                Prompt = MessageFactory.Text("Enter a number."),
                RetryPrompt = MessageFactory.Text("It must be a number")
            }));
        }
 private static async Task <DialogTurnResult> WaterfallStep2(DialogContext dc, WaterfallStepContext stepContext, CancellationToken cancellationToken)
 {
     if (stepContext.Values != null)
     {
         var numberResult = (int)stepContext.Result;
         await dc.Context.SendActivityAsync(MessageFactory.Text($"Thanks for '{numberResult}'"), cancellationToken);
     }
     return(await dc.PromptAsync("number", new PromptOptions { Prompt = MessageFactory.Text("Enter another number.") }, cancellationToken));
 }
示例#9
0
    public override async Task <DialogTurnResult> ResumeDialogAsync(DialogContext outerDc, DialogReason reason, object result = null, CancellationToken cancellationToken = default)
    {
        recursions = Convert.ToInt32(result);
        await outerDc.PromptAsync(nameof(TextPrompt), new PromptOptions
        {
            Prompt = MessageFactory.Text($"Resume root dialog with recursion value {recursions}")
        });

        return(await outerDc.BeginDialogAsync(nameof(WaterfallDialog)));
    }
示例#10
0
 private static async Task <DialogTurnResult> WaterfallStep2(DialogContext dc, WaterfallStepContext stepContext)
 {
     // step context represents values from previous (waterfall) step - in this case the first number
     if (stepContext.Values != null)
     {
         var numberResult = (int)stepContext.Result;
         await dc.Context.SendActivityAsync($"Thanks for '{numberResult}'");
     }
     return(await dc.PromptAsync("number", new PromptOptions { Prompt = MessageFactory.Text("Enter another number.") }));
 }
 public static async Task <DialogTurnResult> BuildConfirmYesNoPrompt(this DialogContext dc, string message = "Please confirm: Yes to proceed or No to cancel", CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await dc.PromptAsync(nameof(ChoicePrompt), new PromptOptions
     {
         Prompt = MessageFactory.Text(message),
         Choices = ChoiceFactory.ToChoices(new List <string>()
         {
             "Yes", "No"
         }),
     }, cancellationToken));
 }
示例#12
0
 public static async Task <DialogTurnResult> ToShow(DialogContext stepContext, CancellationToken cancellationToken)
 {
     return(await stepContext.PromptAsync(
                nameof(TextPrompt),
                new PromptOptions
     {
         Prompt = CreateCarousel()
     },
                cancellationToken
                ));
 }
 public static async Task <DialogTurnResult> BuildMultilineTextPrompt(this DialogContext dc, string[] messages, string finalMessage, CancellationToken cancellationToken = default(CancellationToken))
 {
     foreach (string msg in messages)
     {
         await SendTextActivity(dc.Context, msg, cancellationToken);
     }
     return(await dc.PromptAsync(nameof(TextPrompt), new PromptOptions
     {
         Prompt = MessageFactory.Text(finalMessage)
     }, cancellationToken));
 }
示例#14
0
 public override Task <DialogTurnResult> ContinueDialogAsync(DialogContext outerDc, CancellationToken cancellationToken = default)
 {
     if (!int.TryParse(outerDc.Context.Activity.Text, out var recursions))
     {
         return(outerDc.PromptAsync(nameof(TextPrompt), new PromptOptions()
         {
             Prompt = MessageFactory.Text($"{outerDc.Context.Activity.Text} konnte nicht in eine Zahl konvertiert werden.")
         }));
     }
     return(outerDc.EndDialogAsync(recursions));
 }
示例#15
0
        private static async Task <DialogTurnResult> WaterfallStep1(DialogContext dc, WaterfallStepContext stepContext)
        {
            // we are only interested in Message activities - any other type of activity we will immediately complete teh waterfall
            if (dc.Context.Activity.Type != ActivityTypes.Message)
            {
                return(await dc.EndAsync());
            }

            // this prompt will not continue until we receive a number
            return(await dc.PromptAsync("number", new PromptOptions { Prompt = MessageFactory.Text("Enter a number.") }));
        }
示例#16
0
        private static async Task Waterfall2_Step2(DialogContext dc, object args, SkipStepFunction next)
        {
            if (args != null)
            {
                var numberResult = (NumberResult <int>)args;
                await dc.Context.SendActivityAsync($"Thanks for '{numberResult.Value}'");
            }
            await dc.Context.SendActivityAsync("step2");

            await dc.PromptAsync("number", "Enter a number.", new PromptOptions { RetryPromptString = "It must be a number" });
        }
示例#17
0
        public async Task <DialogTurnResult> OriginStep(DialogContext dc, CancellationToken cancellationToken = default)
        {
            dc.ActiveDialog.State["stepID"] = "OriginStep";

            var options = new string[] { "Kosice", "Bratislava", "Budapest", }.ToList();
            var sizeOptions = new PromptOptions
            {
                Prompt  = MessageFactory.Text("Where would you like to go?"),
                Choices = ChoiceFactory.ToChoices(options),
            };

            return(await dc.PromptAsync(nameof(ChoicePrompt), sizeOptions, cancellationToken));
        }
示例#18
0
        public async Task <DialogTurnResult> DestinationStep(DialogContext dc, CancellationToken cancellationToken = default)
        {
            dc.ActiveDialog.State["stepID"] = "DestinationStep";

            var options = new string[] { "London", "Wiena", "Krakow", }.ToList();
            var sizeOptions = new PromptOptions
            {
                Prompt  = MessageFactory.Text("From where would you like to go?"),
                Choices = ChoiceFactory.ToChoices(options),
            };

            return(await dc.PromptAsync(nameof(ChoicePrompt), sizeOptions, cancellationToken));
        }
示例#19
0
        public async Task <DialogTurnResult> SizeStep(DialogContext dc, CancellationToken cancellationToken = default)
        {
            dc.ActiveDialog.State["stepID"] = "SizeStep";

            var options = new string[] { "Small", "Medium", "Big", }.ToList();
            var sizeOptions = new PromptOptions
            {
                Prompt  = MessageFactory.Text("What size would you like"),
                Choices = ChoiceFactory.ToChoices(options),
            };

            return(await dc.PromptAsync(nameof(ChoicePrompt), sizeOptions, cancellationToken));
        }
示例#20
0
        private static async Task <DialogTurnResult> Waterfall2_Step2(DialogContext dc, WaterfallStepContext stepContext)
        {
            if (stepContext.Values != null)
            {
                var numberResult = (int)stepContext.Result;
                await dc.Context.SendActivityAsync($"Thanks for '{numberResult}'");
            }
            await dc.Context.SendActivityAsync("step2");

            return(await dc.PromptAsync("number",
                                        new PromptOptions {
                Prompt = MessageFactory.Text("Enter a number."),
                RetryPrompt = MessageFactory.Text("It must be a number")
            }));
        }
示例#21
0
        public override async Task <DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)
        {
            if (dc.Context.Activity.Text == "get me out")
            {
                return(await dc.EndDialogAsync("PICA", cancellationToken));
            }

            if (dc.Context.Activity.Text == "prompt")
            {
                var promptMessage = MessageFactory.Text("Hej zidan voco go ??? ", "Hej zidan voco go???", InputHints.ExpectingInput);
                return(await dc.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken));
            }

            if (dc.Context.Activity.Text == "redirect")
            {
                throw new RedirectDialogException();
            }

            await dc.Context.SendActivityAsync($"MUHAHAHAHAHA SI LEN MOJ a znam co pises: {dc.Context.Activity.Text}");

            return(new DialogTurnResult(DialogTurnStatus.Waiting));
        }
 private static async Task <DialogTurnResult> WaterfallStep1(DialogContext dc, WaterfallStepContext stepContext, CancellationToken cancellationToken)
 {
     return(await dc.PromptAsync("number", new PromptOptions { Prompt = MessageFactory.Text("Enter a number.") }, cancellationToken));
 }
示例#23
0
        public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
        {
            // use state accessor to extract the didBotWelcomeUser flag
            var didBotWelcomeUser = await _botSpielUserStateAccessors.DidBotWelcomeUser.GetAsync(turnContext, () => false);

            var currentBotUserData = await _botSpielUserStateAccessors.BotUserDataAccessor.GetAsync(turnContext, () => _botUserData);

            string        conCat          = "";
            List <string> existInEntities = new List <string>();
            bool          DeleteOK        = true;

            if (turnContext.Activity.Type == ActivityTypes.Message)
            {
                // Establish dialog state from the conversation state.
                DialogContext dc = await _dialogs.CreateContextAsync(turnContext, cancellationToken);

                //Custom Code Start | Added Code Block
                if (turnContext.Activity.Text.ToLowerInvariant() == "cancel")
                {
                    await dc.CancelAllDialogsAsync(cancellationToken);
                }
                //Custom Code End

                // Continue any current dialog.
                DialogTurnResult dialogTurnResult = await dc.ContinueDialogAsync();

                // Process the result of any complete dialog.
                if (dialogTurnResult.Status is DialogTurnStatus.Complete)
                {
                    switch (dialogTurnResult.Result)
                    {
                    case BotUserEntityContext botUserEntityContext:
                        if (botUserEntityContext.module != "Choose an area")
                        {
                            // Store the results of the root dialog.
                            currentBotUserData.botUserEntityContext = botUserEntityContext;
                            await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                            await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                            await dc.PromptAsync(ConfirmPromptId, new PromptOptions { Prompt = MessageFactory.Text($"Please confirm that you want to {botUserEntityContext.entityIntent} {botUserEntityContext.entity}. Is that correct?") }, cancellationToken);
                        }
                        else
                        {
                            await turnContext.SendActivityAsync("OK, Let's choose a different area.", cancellationToken : cancellationToken);

                            await dc.BeginDialogAsync(RootDialogId, null, cancellationToken);
                        }
                        break;

                    case bool botYesNo:
                        if (botYesNo)
                        {
                            switch (currentBotUserData.botUserEntityContext.entity)
                            {
                            case "PickBatchPicking":
                                if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                                {
                                    //Custom Code Start | Replaced Code Block
                                    //Replaced Code Block Start
                                    //await dc.BeginDialogAsync(CreatePickBatchPickingDialogId, null, cancellationToken);
                                    //Replaced Code Block End
                                    await dc.BeginDialogAsync(CreatePickBatchPickingDialogId, new PickBatchPickingPost(), cancellationToken);

                                    //Custom Code End
                                }
                                break;

                            case "PutAwayHandlingUnits":
                                if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                                {
                                    await dc.BeginDialogAsync(CreatePutAwayHandlingUnitsDialogId, null, cancellationToken);
                                }
                                break;

                            case "SetUpExecutionParameters":
                                if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                                {
                                    await dc.BeginDialogAsync(CreateSetUpExecutionParametersDialogId, null, cancellationToken);
                                }
                                break;

                            case "DropInventoryUnits":
                                if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                                {
                                    await dc.BeginDialogAsync(CreateDropInventoryUnitsDialogId, null, cancellationToken);
                                }
                                break;

                            default:
                                // We shouldn't get here.
                                break;
                            }
                        }
                        else
                        {
                            await turnContext.SendActivityAsync(MessageFactory.Text("OK, let's try again."), cancellationToken);

                            await dc.BeginDialogAsync(RootDialogId, null, cancellationToken);
                        }
                        break;

                    case GetPickBatchesPost getpickbatchesPost:
                        if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                        {
                            //Custom Code Start | Removed Block
                            //ixGetPickBatch = await _getpickbatchesService.Create(getpickbatchesPost);
                            //await turnContext.SendActivityAsync(MessageFactory.Text($"The GetPickBatch {ixGetPickBatch} was created"), cancellationToken);
                            //currentBotUserData.ixGetPickBatch = ixGetPickBatch;
                            //Custom Code End

                            await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                            await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                            //await dc.BeginDialogAsync(RootDialogId, currentBotUserData.botUserEntityContext, cancellationToken);

                            //Custom Code Start | Added Code Block
                            //We can now set the pick batch status to started
                            var pickbatch = _pickbatchesService.GetPost(_pickbatchesService.IndexDb().Where(x => x.sPickBatch == getpickbatchesPost.sGetPickBatch).Select(x => x.ixPickBatch).FirstOrDefault());
                            pickbatch.ixStatus = _commonLookUps.getStatuses().Where(x => x.sStatus == "Started").Select(x => x.ixStatus).FirstOrDefault();
                            pickbatch.UserName = dc.Context.Activity.Conversation.Id;
                            await _pickbatchesService.Edit(pickbatch);

                            _pickbatchpickingPost.sPickBatchPick = getpickbatchesPost.sGetPickBatch;
                            await dc.BeginDialogAsync(CreatePickBatchPickingDialogId, _pickbatchpickingPost, cancellationToken);

                            //Custom Code End
                        }
                        break;

                    case PickBatchPickingPost pickbatchpickingPost:
                        if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                        {
                            ixPickBatchPick = await _pickbatchpickingService.Create(pickbatchpickingPost);

                            //Custom Code Start | Removed Block
                            //await turnContext.SendActivityAsync(MessageFactory.Text($"The PickBatchPick {ixPickBatchPick} was created"), cancellationToken);
                            //Custom Code End
                            //Custom Code Start | Added Code Block
                            //We check if the batch is complete
                            if (!_picking.isPickBatchComplete(pickbatchpickingPost.ixPickBatch))
                            {
                                currentBotUserData.ixPickBatchPick = ixPickBatchPick;
                                await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                                await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                                await dc.BeginDialogAsync(CreatePickBatchPickingDialogId, pickbatchpickingPost, cancellationToken);
                            }
                            else
                            {
                                currentBotUserData.ixPickBatchPick = 0;
                                await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                                await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                                //await dc.BeginDialogAsync(RootDialogId, currentBotUserData.botUserEntityContext, cancellationToken);
                                //We can now set the pick batch status to complete
                                var pickbatch = _pickbatchesService.GetPost(pickbatchpickingPost.ixPickBatch);
                                pickbatch.ixStatus = _commonLookUps.getStatuses().Where(x => x.sStatus == "Complete").Select(x => x.ixStatus).FirstOrDefault();
                                pickbatch.UserName = dc.Context.Activity.Conversation.Id;
                                await _pickbatchesService.Edit(pickbatch);

                                //We begin the drop cycle
                                await dc.BeginDialogAsync(CreateDropInventoryUnitsDialogId, pickbatchpickingPost, cancellationToken);
                            }
                            //Custom Code End
                        }
                        break;

                    case PutAwayHandlingUnitsPost putawayhandlingunitsPost:
                        if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                        {
                            ixPutAwayHandlingUnit = await _putawayhandlingunitsService.Create(putawayhandlingunitsPost);

                            //Custom Code Start | Removed Block
                            //await turnContext.SendActivityAsync(MessageFactory.Text($"The PutAwayHandlingUnit {ixPutAwayHandlingUnit} was created"), cancellationToken);
                            //Custom Code End
                            currentBotUserData.ixPutAwayHandlingUnit = ixPutAwayHandlingUnit;
                            await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                            await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                            //Custom Code Start | Replaced Code Block
                            //Replaced Code Block Start
                            //await dc.BeginDialogAsync(RootDialogId, currentBotUserData.botUserEntityContext, cancellationToken);
                            //Replaced Code Block End
                            await dc.BeginDialogAsync(CreatePutAwayHandlingUnitsDialogId, null, cancellationToken);

                            //Custom Code End
                        }
                        break;

                    case SetUpExecutionParametersPost setupexecutionparametersPost:
                        if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                        {
                            //Custom Code Start | Removed Block
                            //ixSetUpExecutionParameter = await _setupexecutionparametersService.Create(setupexecutionparametersPost);
                            //await turnContext.SendActivityAsync(MessageFactory.Text($"The SetUpExecutionParameter {ixSetUpExecutionParameter} was created"), cancellationToken);
                            //currentBotUserData.ixSetUpExecutionParameter = ixSetUpExecutionParameter;
                            //Custom Code End
                            //Custom Code Start | Added Code Block
                            currentBotUserData.ixFacility         = setupexecutionparametersPost.ixFacility;
                            currentBotUserData.ixCompany          = setupexecutionparametersPost.ixCompany;
                            currentBotUserData.ixFacilityWorkArea = setupexecutionparametersPost.ixFacilityWorkArea;
                            //We check if the user location exists - if not we create it
                            if (_userManager.Users.Where(x => x.UserName == dc.Context.Activity.Conversation.Id).Any())
                            {
                                if (!_inventorylocationsService.IndexDb().Where(x => x.sInventoryLocation.ToLower().Trim() == dc.Context.Activity.Conversation.Id.ToLower().Trim()).Any())
                                {
                                    InventoryLocationsPost inventoryLocationsPost = new InventoryLocationsPost();
                                    inventoryLocationsPost.sInventoryLocation  = dc.Context.Activity.Conversation.Id.ToLower().Trim();
                                    inventoryLocationsPost.ixLocationFunction  = _locationfunctionsService.IndexDb().Where(x => x.sLocationFunctionCode == "PE").Select(x => x.ixLocationFunction).FirstOrDefault();
                                    inventoryLocationsPost.ixFacility          = currentBotUserData.ixFacility;
                                    inventoryLocationsPost.ixFacilityFloor     = _inventorylocationsService.FacilityFloorsDb().Select(x => x.ixFacilityFloor).FirstOrDefault();
                                    inventoryLocationsPost.ixFacilityZone      = _inventorylocationsService.FacilityZonesDb().Select(x => x.ixFacilityZone).FirstOrDefault();
                                    inventoryLocationsPost.ixFacilityWorkArea  = _inventorylocationsService.FacilityWorkAreasDb().Select(x => x.ixFacilityWorkArea).FirstOrDefault();
                                    inventoryLocationsPost.ixFacilityAisleFace = _inventorylocationsService.FacilityAisleFacesDb().Select(x => x.ixFacilityAisleFace).FirstOrDefault();
                                    inventoryLocationsPost.nSequence           = 0;
                                    inventoryLocationsPost.bTrackUtilisation   = false;
                                    currentBotUserData.ixInventoryLocation     = await _inventorylocationsService.Create(inventoryLocationsPost);
                                }
                                else
                                {
                                    currentBotUserData.ixInventoryLocation = _inventorylocationsService.IndexDb().Where(x => x.sInventoryLocation.ToLower().Trim() == dc.Context.Activity.Conversation.Id.ToLower().Trim()).Select(x => x.ixInventoryLocation).FirstOrDefault();
                                    var inventoryLocationsPost = _inventorylocationsService.GetPost(currentBotUserData.ixInventoryLocation);
                                    inventoryLocationsPost.ixFacility = currentBotUserData.ixFacility;
                                    await _inventorylocationsService.Edit(inventoryLocationsPost);
                                }
                            }
                            //Custom Code End
                            await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                            await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                            //Custom Code Start | Removed Block
                            //await dc.BeginDialogAsync(RootDialogId, currentBotUserData.botUserEntityContext, cancellationToken);
                            //Custom Code End
                            //Custom Code Start | Added Code Block
                            await turnContext.SendActivityAsync(MessageFactory.Text($"The setup parameters have been updated. Say/type putaway, pick or cancel."), cancellationToken);

                            //Custom Code End
                        }
                        break;

                    case DropInventoryUnitsPost dropinventoryunitsPost:
                        if (currentBotUserData.botUserEntityContext.entityIntent == "Create")
                        {
                            //Custom Code Start | Removed Block
                            //ixDropInventoryUnit = await _dropinventoryunitsService.Create(dropinventoryunitsPost);
                            //await turnContext.SendActivityAsync(MessageFactory.Text($"The DropInventoryUnit {ixDropInventoryUnit} was created"), cancellationToken);
                            //currentBotUserData.ixDropInventoryUnit = ixDropInventoryUnit;
                            //await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);
                            //await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);
                            //await dc.BeginDialogAsync(RootDialogId, currentBotUserData.botUserEntityContext, cancellationToken);
                            //Custom Code End
                            await dc.BeginDialogAsync(CreateGetPickBatchesDialogId, null, cancellationToken);
                        }
                        break;

                    default:
                        // We shouldn't get here.
                        break;
                    }
                }

                // Proactively send a welcome message to a personal chat the first time
                // (and only the first time) a user initiates a personal chat.
                //Custom Code Start | Replaced Code Block
                //Replaced Code Block Start
                //if (didBotWelcomeUser == false)
                //Replaced Code Block End
                if (true == false)
                //Custom Code End
                {
                    // Update user state flag to reflect bot handled first user interaction.
                    await _botSpielUserStateAccessors.DidBotWelcomeUser.SetAsync(turnContext, true);

                    await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                    // the channel should sends the user name in the 'From' object
                    var userName = turnContext.Activity.From.Name;

                    // We give the user the opportunity to say or request something using natural language and funnel through recognizer
                    await turnContext.SendActivityAsync($"What would like to do? You can say things like ... or help me.", cancellationToken : cancellationToken);
                }
                //Custom Code Start | Added Code Block
                else if (!currentBotUserData.bIsInitialSetUpParametersSet)
                {
                    currentBotUserData.bIsInitialSetUpParametersSet      = true;
                    currentBotUserData.botUserEntityContext.module       = "Execution";
                    currentBotUserData.botUserEntityContext.entity       = "SetUpExecutionParameters";
                    currentBotUserData.botUserEntityContext.entityIntent = "Create";
                    await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                    await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                    await dc.BeginDialogAsync(CreateSetUpExecutionParametersDialogId, null, cancellationToken);
                }
                //Custom Code End
                else if ((dialogTurnResult.Status is DialogTurnStatus.Empty) || turnContext.Activity.Text.ToLowerInvariant() == "putaway" || turnContext.Activity.Text.ToLowerInvariant() == "cancel")
                {
                    var text = turnContext.Activity.Text.ToLowerInvariant();

                    // Now attempt to infer the context (NLP)
                    // Placeholder for code to added

                    switch (text)
                    {
                    //Custom Code Start | Removed Block
                    //case "help me":
                    //    await turnContext.SendActivityAsync($"You said: {text}.", cancellationToken: cancellationToken);
                    //    break;
                    //Custom Code End
                    //Custom Code Start | Added Code Block
                    case "putaway":
                        currentBotUserData.botUserEntityContext.module       = "Execution";
                        currentBotUserData.botUserEntityContext.entity       = "PutAwayHandlingUnits";
                        currentBotUserData.botUserEntityContext.entityIntent = "Create";
                        await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                        await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                        await dc.BeginDialogAsync(CreatePutAwayHandlingUnitsDialogId, null, cancellationToken);

                        break;

                    case "pick":
                        currentBotUserData.botUserEntityContext.module       = "Execution";
                        currentBotUserData.botUserEntityContext.entity       = "PickBatchPicking";
                        currentBotUserData.botUserEntityContext.entityIntent = "Create";
                        await _botSpielUserStateAccessors.BotUserDataAccessor.SetAsync(turnContext, currentBotUserData, cancellationToken);

                        await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

                        //await dc.BeginDialogAsync(CreatePickBatchPickingDialogId, new PickBatchPickingPost(), cancellationToken);
                        await dc.BeginDialogAsync(CreateGetPickBatchesDialogId, null, cancellationToken);

                        break;

                    case "cancel":
                        await dc.CancelAllDialogsAsync(cancellationToken);

                        break;

                    //Custom Code End
                    default:
                        if (dc.ActiveDialog == null && (dialogTurnResult.Status is DialogTurnStatus.Complete || dialogTurnResult.Status is DialogTurnStatus.Empty || dialogTurnResult.Status is DialogTurnStatus.Cancelled))
                        {
                            await turnContext.SendActivityAsync("I do not understand, let's try something different.", cancellationToken : cancellationToken);

                            await dc.BeginDialogAsync(RootDialogId, null, cancellationToken);
                        }
                        break;
                    }
                }
            }
            else if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate)
            {
                if (turnContext.Activity.MembersAdded.Any())
                {
                    // Iterate over all new members added to the conversation
                    foreach (var member in turnContext.Activity.MembersAdded)
                    {
                        if (member.Id != turnContext.Activity.Recipient.Id)
                        {
                            await turnContext.SendActivityAsync($"Hi there - {member.Name}. {WelcomeMessage}", cancellationToken : cancellationToken);
                        }
                    }
                }
            }
            else
            {
                // Default behaviour for all other type of activities.
                await turnContext.SendActivityAsync($"{turnContext.Activity.Type} activity detected");
            }

            // save any state changes made to your state objects.
            await _botSpielUserStateAccessors.UserState.SaveChangesAsync(turnContext);

            await _botSpielUserStateAccessors.ConversationState.SaveChangesAsync(turnContext);
        }
 public async Task <DialogTurnResult> PromptAsync(DialogContext dialogContext,
                                                  string dialogId, PromptOptions options,
                                                  CancellationToken cancellationToken) =>
 await dialogContext.PromptAsync(dialogId, options);
示例#25
0
        public async override Task <DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default(CancellationToken))
        {
            var context = dc.Context;

            // Get turn counter
            var turnCounter = await _turnCounterAccessor.GetAsync(context, () => new CounterState());

            turnCounter.TurnCount = ++turnCounter.TurnCount;

            // Set updated turn counter
            await _turnCounterAccessor.SetAsync(context, turnCounter);

            // See if we have card input. This would come in through onTurnProperty
            var onTurnProperty = await _onTurnAccessor.GetAsync(context);

            if (onTurnProperty != null)
            {
                if (onTurnProperty.Entities.Count > 0)
                {
                    // find user name in on turn property
                    var userNameInOnTurnProperty = onTurnProperty.Entities.FirstOrDefault(item => string.Compare(item.EntityName, UserName, StringComparison.Ordinal) == 0);
                    if (userNameInOnTurnProperty != null)
                    {
                        var userName = userNameInOnTurnProperty.Value as string;
                        if (!string.IsNullOrWhiteSpace(userName))
                        {
                            await UpdateUserProfilePropertyAsync(userName, context);
                        }

                        return(await ContinueDialogAsync(dc));
                    }
                }
            }

            if (turnCounter.TurnCount >= 1)
            {
                // We need to get user's name right. Include a card.
                var activity = dc.Context.Activity.CreateReply();
                activity.Attachments = new List <Attachment> {
                    Helpers.CreateAdaptiveCardAttachment(@".\Dialogs\WhoAreYou\Resources\getNameCard.json"),
                };
                await context.SendActivityAsync(activity);
            }
            else if (turnCounter.TurnCount >= 3)
            {
                // We are not going to spend more than 3 turns to get user's name.
                return(await EndGetUserNamePromptAsync(dc));
            }

            // Call LUIS and get results
            var luisResults = await _botServices.LuisServices[LuisConfiguration].RecognizeAsync(context, cancellationToken);

            var topLuisIntent = luisResults.GetTopScoringIntent();
            var topIntent     = topLuisIntent.intent;

            if (string.IsNullOrWhiteSpace(topIntent))
            {
                // Go with intent in onTurnProperty
                topIntent = string.IsNullOrWhiteSpace(onTurnProperty.Intent) ? "None" : onTurnProperty.Intent;
            }

            // Did user ask for help or said they are not going to give us the name?
            switch (topIntent)
            {
            case NoNameIntent:
                // Set user name in profile to Human
                await _userProfileAccessor.SetAsync(context, new UserProfile("Human"));

                return(await EndGetUserNamePromptAsync(dc));

            case GetUserNameIntent:
                // Find the user's name from LUIS entities list.
                if (luisResults.Entities.TryGetValue(UserName, out var entity))
                {
                    var userName = (string)entity[0];
                    await UpdateUserProfilePropertyAsync(userName, context);

                    return(await base.ContinueDialogAsync(dc));
                }
                else if (luisResults.Entities.TryGetValue(UserNamePatternAny, out var entity_pattery))
                {
                    var userName = (string)entity_pattery[0];
                    await UpdateUserProfilePropertyAsync(userName, context);

                    return(await base.ContinueDialogAsync(dc));
                }
                else
                {
                    await context.SendActivityAsync("Sorry, I didn't get that. What's your name ?");

                    return(await base.ContinueDialogAsync(dc));
                }

            case WhyDoYouAsk:
                await context.SendActivityAsync("I need your name to be able to address you correctly!");

                await context.SendActivityAsync(MessageFactory.SuggestedActions(new List <string> {
                    "I won't give you my name", "What is your name?"
                }));

                return(await base.ContinueDialogAsync(dc));

            case NoneIntent:
                await UpdateUserProfilePropertyAsync(context.Activity.Text, context);

                return(await base.ContinueDialogAsync(dc));

            case CancelIntent:
                // Start confirmation prompt
                var opts = new PromptOptions
                {
                    Prompt = new Activity
                    {
                        Type = ActivityTypes.Message,
                        Text = "Are you sure you want to cancel ?",
                    },
                };
                return(await dc.PromptAsync(ConfirmCancelPrompt, opts));

            default:
                // Handle interruption.
                var onTurnPropertyValue = await _onTurnAccessor.GetAsync(dc.Context);

                return(await dc.BeginDialogAsync(InterruptionDispatcher, onTurnPropertyValue));
            }
        }
示例#26
0
        public async override Task <DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default(CancellationToken))
        {
            var turnContext = dc.Context;
            var step        = dc.ActiveDialog.State;

            // Get reservation property.
            var newReservation = await _reservationsAccessor.GetAsync(turnContext, () => new ReservationProperty());

            // Get on turn property. This has any entities that mainDispatcher,
            // or Bot might have captured in its LUIS model.
            var onTurnProperties = await _onTurnAccessor.GetAsync(turnContext, () => new OnTurnProperty("None", new List <EntityProperty>()));

            // If on turn property has entities..
            ReservationResult updateResult = null;

            if (onTurnProperties.Entities.Count > 0)
            {
                // ...update reservation property with on turn property results.
                updateResult = newReservation.UpdateProperties(onTurnProperties);
            }

            // See if updates to reservation resulted in errors, if so, report them to user.
            if (updateResult != null &&
                updateResult.Status == ReservationStatus.Incomplete &&
                updateResult.Outcome != null &&
                updateResult.Outcome.Count > 0)
            {
                await _reservationsAccessor.SetAsync(turnContext, updateResult.NewReservation);

                // Return and do not continue if there is an error.
                await turnContext.SendActivityAsync(updateResult.Outcome[0].Message);

                return(await base.ContinueDialogAsync(dc));
            }

            // Call LUIS and get results.
            var luisResults   = await _botServices.LuisServices[LuisConfiguration].RecognizeAsync(turnContext, cancellationToken);
            var topLuisIntent = luisResults.GetTopScoringIntent();
            var topIntent     = topLuisIntent.intent;

            // If we don't have an intent match from LUIS, go with the intent available via
            // the on turn property (parent's LUIS model).
            if (luisResults.Intents.Count <= 0)
            {
                // Go with intent in onTurnProperty.
                topIntent = string.IsNullOrWhiteSpace(onTurnProperties.Intent) ? "None" : onTurnProperties.Intent;
            }

            // Update object with LUIS result.
            updateResult = newReservation.UpdateProperties(OnTurnProperty.FromLuisResults(luisResults));

            // See if update reservation resulted in errors, if so, report them to user.
            if (updateResult != null &&
                updateResult.Status == ReservationStatus.Incomplete &&
                updateResult.Outcome != null &&
                updateResult.Outcome.Count > 0)
            {
                // Set reservation property.
                await _reservationsAccessor.SetAsync(turnContext, updateResult.NewReservation);

                // Return and do not continue if there is an error.
                await turnContext.SendActivityAsync(updateResult.Outcome[0].Message);

                return(await base.ContinueDialogAsync(dc));
            }

            // Did user ask for help or said cancel or continuing the conversation?
            switch (topIntent)
            {
            case ContinuePromptIntent:
                // User does not want to make any change.
                updateResult.NewReservation.NeedsChange = false;
                break;

            case NoChangeIntent:
                // User does not want to make any change.
                updateResult.NewReservation.NeedsChange = false;
                break;

            case HelpIntent:
                // Come back with contextual help.
                var helpReadOut = updateResult.NewReservation.HelpReadOut();
                await turnContext.SendActivityAsync(helpReadOut);

                break;

            case CancelIntent:
                // Start confirmation prompt.
                var opts = new PromptOptions
                {
                    Prompt = new Activity
                    {
                        Type = ActivityTypes.Message,
                        Text = "Are you sure you want to cancel?",
                    },
                };

                return(await dc.PromptAsync(ConfirmCancelPrompt, opts));

            case InterruptionsIntent:
            default:
                // If we picked up new entity values, do not treat this as an interruption.
                if (onTurnProperties.Entities.Count != 0 || luisResults.Entities.Count > 1)
                {
                    break;
                }

                // Handle interruption.
                var onTurnProperty = await _onTurnAccessor.GetAsync(dc.Context);

                return(await dc.BeginDialogAsync(InterruptionDispatcher, onTurnProperty));
            }

            // Set reservation property based on OnTurn properties.
            await _reservationsAccessor.SetAsync(turnContext, updateResult.NewReservation);

            return(await base.ContinueDialogAsync(dc));
        }
示例#27
0
        private static async Task Waterfall2_Step1(DialogContext dc, object args, SkipStepFunction next)
        {
            await dc.Context.SendActivityAsync("step1");

            await dc.PromptAsync("number", "Enter a number.", new PromptOptions { RetryPromptString = "It must be a number" });
        }