public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
// Ensure planning context
if (dc is SequenceContext planning)
{
var(value, error) = condition.TryEvaluate(dc.GetState());
var conditionResult = error == null && value != null && (bool)value;
if (conditionResult == true && TrueScope.Actions.Any())
{
// replace dialog with If True Action Scope
return(await dc.ReplaceDialogAsync(this.TrueScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
else if (conditionResult == false && FalseScope.Actions.Any())
{
return(await dc.ReplaceDialogAsync(this.FalseScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
// end dialog since no triggered actions
return(await planning.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
else
{
throw new Exception("`IfCondition` should only be used in the context of an adaptive dialog.");
}
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
if (this.Disabled != null && this.Disabled.GetValue(dc.State) == true)
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
var(conditionResult, error) = this.Condition.TryGetValue(dc.State);
if (error == null && conditionResult == true && TrueScope.Actions.Any())
{
// replace dialog with If True Action Scope
return(await dc.ReplaceDialogAsync(this.TrueScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
else if (conditionResult == false && FalseScope.Actions.Any())
{
return(await dc.ReplaceDialogAsync(this.FalseScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
// end dialog since no triggered actions
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Called when the dialog is started and pushed onto the dialog stack.
/// </summary>
/// <param name="dc">The <see cref="DialogContext"/> for the current turn of conversation.</param>
/// <param name="options">Optional, initial information to pass to the dialog.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
if (string.IsNullOrEmpty(Condition.ExpressionText))
{
throw new InvalidOperationException("Adaptive Dialogs error: Missing predicate condition. Please add a valid predicate to the Condition property of IfCondition().");
}
if (Disabled != null && Disabled.GetValue(dc.State))
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
var(conditionResult, error) = this.Condition.TryGetValue(dc.State);
if (error == null && conditionResult == true && TrueScope.Actions.Any())
{
// replace dialog with If True Action Scope
return(await dc.ReplaceDialogAsync(this.TrueScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
else if (conditionResult == false && FalseScope.Actions.Any())
{
return(await dc.ReplaceDialogAsync(this.FalseScope.Id, cancellationToken : cancellationToken).ConfigureAwait(false));
}
// end dialog since no triggered actions
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
private async Task <DialogTurnResult> InterruptAsync(DialogContext innerDc, CancellationToken cancellationToken)
{
if (innerDc.Context.Activity.Type == ActivityTypes.Message)
{
var text = innerDc.Context.Activity.Text.ToLower();
var _DialogInfo = await _dialogInfoStateProperty.GetAsync(innerDc.Context);
switch (text)
{
case "lang":
await innerDc.ReplaceDialogAsync(nameof(LanguageDialog), "ChangeLanguage",
cancellationToken : cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
case "restart":
case "again":
case "new":
case "reload":
innerDc.Context.Activity.Text = "begin";
await innerDc.ReplaceDialogAsync(nameof(LocationDialog), "begin", cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
case "quit":
case "exit":
await innerDc.Context.SendActivityAsync($"Cancelling", cancellationToken : cancellationToken);
return(await innerDc.CancelAllDialogsAsync());
case "sub":
case "subscriptions":
await innerDc.ReplaceDialogAsync(nameof(SubscriptionDialog),
cancellationToken : cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
case "email":
await innerDc.ReplaceDialogAsync(nameof(EmailDialog),
cancellationToken : cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
case "help":
await innerDc.ReplaceDialogAsync(nameof(HelpDialog),
cancellationToken : cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
}
}
return(null);
}
// Runs when this dialog ends. Handles result of prompt to switch skills or resume waiting dialog.
protected override async Task <DialogTurnResult> EndComponentAsync(DialogContext outerDc, object result, CancellationToken cancellationToken)
{
var skillId = await _skillIdAccessor.GetAsync(outerDc.Context, () => null).ConfigureAwait(false);
var lastActivity = await _lastActivityAccessor.GetAsync(outerDc.Context, () => null).ConfigureAwait(false);
outerDc.Context.Activity.Text = lastActivity.Text;
// Ends this dialog.
await outerDc.EndDialogAsync().ConfigureAwait(false);
if ((bool)result)
{
// If user decided to switch, replace current skill dialog with new skill dialog.
var skillDialogArgs = new SkillDialogArgs {
SkillId = skillId
};
// Start the skill dialog.
return(await outerDc.ReplaceDialogAsync(skillId, skillDialogArgs).ConfigureAwait(false));
}
else
{
// Otherwise, continue the waiting skill dialog with the user's previous utterance.
return(await outerDc.ContinueDialogAsync().ConfigureAwait(false));
}
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
var dcState = dc.GetState();
if (this.Disabled != null && this.Disabled.GetValue(dcState) == true)
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
var dialog = this.ResolveDialog(dc);
// use bindingOptions to bind to the bound options
var boundOptions = BindOptions(dc, options);
// set the activity processed state (default is true)
dcState.SetValue(TurnPath.ACTIVITYPROCESSED, this.ActivityProcessed.GetValue(dcState));
// replace dialog with bound options passed in as the options
return(await dc.ReplaceDialogAsync(dialog.Id, options : boundOptions, cancellationToken : cancellationToken).ConfigureAwait(false));
}
private async Task <DialogTurnResult> InterruptAsync(DialogContext innerDc, CancellationToken cancellationToken)
{
if (innerDc.Context.Activity.Type == ActivityTypes.Message)
{
var text = innerDc.Context.Activity.Text.ToLowerInvariant();
switch (text)
{
case "help":
case "?":
var helpMessage = MessageFactory.Text(HelpMsgText, HelpMsgText, InputHints.ExpectingInput);
await innerDc.Context.SendActivityAsync(helpMessage, cancellationToken);
return(new DialogTurnResult(DialogTurnStatus.Waiting));
case "cancel":
case "quit":
var cancelMessage = MessageFactory.Text(CancelMsgText, CancelMsgText, InputHints.IgnoringInput);
await innerDc.Context.SendActivityAsync(cancelMessage, cancellationToken);
await innerDc.CancelAllDialogsAsync(cancellationToken);
return(await innerDc.ReplaceDialogAsync(nameof(MainDialog), null, cancellationToken : cancellationToken));
//return await innerDc.CancelAllDialogsAsync(cancellationToken);
}
}
return(null);
}
/// <summary>
/// This override is used to test the "abort" command to interrupt skills from the parent and
/// also to test the "tangent" command to start a tangent and resume a skill.
/// </summary>
/// <param name="innerDc">The inner <see cref="DialogContext"/> for the current turn of conversation.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected override async Task <DialogTurnResult> OnContinueDialogAsync(DialogContext innerDc, CancellationToken cancellationToken = default)
{
// This is an example on how to cancel a SkillDialog that is currently in progress from the parent bot.
var activeSkill = await _activeSkillProperty.GetAsync(innerDc.Context, () => null, cancellationToken);
var activity = innerDc.Context.Activity;
if (activeSkill != null && activity.Type == ActivityTypes.Message && activity.Text.Equals("abort", StringComparison.CurrentCultureIgnoreCase))
{
// Cancel all dialogs when the user says abort.
// The SkillDialog automatically sends an EndOfConversation message to the skill to let the
// skill know that it needs to end its current dialogs, too.
await innerDc.CancelAllDialogsAsync(cancellationToken);
return(await innerDc.ReplaceDialogAsync(InitialDialogId, "Canceled! \n\n What skill would you like to call?", cancellationToken));
}
// Sample to test a tangent when in the middle of a skill conversation.
if (activeSkill != null && activity.Type == ActivityTypes.Message && activity.Text.Equals("tangent", StringComparison.CurrentCultureIgnoreCase))
{
// Start tangent.
return(await innerDc.BeginDialogAsync(nameof(TangentDialog), cancellationToken : cancellationToken));
}
return(await base.OnContinueDialogAsync(innerDc, cancellationToken));
}
// Runs when this dialog ends. Handles result of prompt to switch skills or resume waiting dialog.
protected override async Task <DialogTurnResult> EndComponentAsync(DialogContext outerDc, object result, CancellationToken cancellationToken)
{
var skillId = await _skillIdAccessor.GetAsync(outerDc.Context, () => null).ConfigureAwait(false);
var lastActivity = await _lastActivityAccessor.GetAsync(outerDc.Context, () => null).ConfigureAwait(false);
outerDc.Context.Activity.Text = lastActivity.Text;
if ((bool)result)
{
// If user decided to switch, replace current skill dialog with new skill dialog.
var skillDialogOptions = new BeginSkillDialogOptions {
Activity = outerDc.Context.Activity
};
// End the SwitchSkillDialog without triggering the ResumeDialog function of current SkillDialog
outerDc.Stack.RemoveAt(0);
// Start the skill dialog.
return(await outerDc.ReplaceDialogAsync(skillId, skillDialogOptions).ConfigureAwait(false));
}
else
{
// Ends this dialog.
return(await outerDc.EndDialogAsync().ConfigureAwait(false));
}
}
private async Task <DialogTurnResult> InterruptAsync(DialogContext innerDc, CancellationToken cancellationToken)
{
if (innerDc.Context.Activity.Type == ActivityTypes.Message)
{
var text = innerDc.Context.Activity.Text.ToLowerInvariant();
switch (text)
{
case "help":
case "?":
await innerDc.Context.SendActivityAsync($"Show Help...", cancellationToken : cancellationToken);
// When you have Q&A Dialog, you can redirect conversation to that Dialog
return(await innerDc.ReplaceDialogAsync(nameof(RootDialog), cancellationToken : cancellationToken));
case "cancel":
case "quit":
await innerDc.Context.SendActivityAsync($"Cancelling", cancellationToken : cancellationToken);
return(await innerDc.CancelAllDialogsAsync(cancellationToken : cancellationToken));
}
}
return(null);
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
var dcState = dc.GetState();
if (this.Disabled != null && this.Disabled.GetValue(dcState) == true)
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
// Ensure planning context
if (dc is SequenceContext planning)
{
lock (this.Condition)
{
if (this.caseExpressions == null)
{
this.caseExpressions = new Dictionary <string, Expression>();
foreach (var cse in this.Cases)
{
// Values for cases are always coerced to string
var caseCondition = Expression.EqualsExpression(this.Condition.ToExpression(), cse.CreateValueExpression());
// Map of expression to actions
this.caseExpressions[cse.Value] = caseCondition;
}
}
}
ActionScope actionScope = this.DefaultScope;
foreach (var caseScope in this.Cases)
{
var(value, error) = this.caseExpressions[caseScope.Value].TryEvaluate(dcState);
if (error != null)
{
throw new Exception($"Expression evaluation resulted in an error. Expression: {caseExpressions[caseScope.Value].ToString()}. Error: {error}");
}
// Compare both expression results. The current switch case triggers if the comparison is true.
if (((bool)value) == true)
{
actionScope = caseScope;
break;
}
}
return(await dc.ReplaceDialogAsync(actionScope.Id, null, cancellationToken : cancellationToken).ConfigureAwait(false));
}
else
{
throw new Exception("`IfCondition` should only be used in the context of an adaptive dialog.");
}
}
private async Task ExecuteActions(DialogContext dc, IEnumerable <CommandAction> actions)
{
var activities = new List <IActivity>();
var actionStack = new Stack <CommandAction>(actions.Reverse());
// Process each action in turn, populating the activities list.
CommandAction action;
while (actionStack.TryPop(out action))
{
var nextDialogAction = action.Execute(dc, activities, _gameFlags);
if (nextDialogAction.NextDialogType != DialogType.None)
{
// If the result of the action indicates that we need to start a new dialog
// (e.g. conversation with an actor, or a switch to a new room), first send all
// activities collected up to this point to the client.
if (activities.Any())
{
await dc.Context.SendActivitiesAsync(activities.ToArray());
}
if (nextDialogAction.NextDialogType == DialogType.Conversation)
{
// If the player starts a conversation, save any remaining actions to the state.
// These will be executed when the conversation is done and this dialog
// continues.
if (actionStack.Any())
{
// Conver to List because Stacks don't serialize in the correct order.
// See https://github.com/JamesNK/Newtonsoft.Json/issues/971.
dc.ActiveDialog.State.Add(DialogStatePendingActions, actionStack.ToList());
}
// Start the conversation.
await dc.BeginDialogAsync(nextDialogAction.NextDialogId);
}
else
{
// Switch to the new room.
await dc.ReplaceDialogAsync(nextDialogAction.NextDialogId);
}
// Stop processing any further actions now that we've switched to a new dialog.
return;
}
}
// Add an Idle activity to let the GUI know that we're waiting for user interaction.
activities.Add(CreateEventActivity(dc, "Idle"));
await dc.Context.SendActivitiesAsync(activities.ToArray());
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
var dialog = this.ResolveDialog(dc);
// use bindingOptions to bind to the bound options
var boundOptions = BindOptions(dc, options);
// replace dialog with bound options passed in as the options
return(await dc.ReplaceDialogAsync(dialog.Id, options : boundOptions, cancellationToken : cancellationToken).ConfigureAwait(false));
}
private async Task <DialogTurnResult> FinishInsuranceTypeStep(DialogContext stepContext, string insuranceType)
{
var context = stepContext.Context;
if (string.Equals(insuranceType, "car", StringComparison.OrdinalIgnoreCase))
{
return(await stepContext.ReplaceDialogAsync(PromptStep.GatherInfo));
}
else
{
await context.SendActivityAsync($"Right now I can only help with car insurance: {insuranceType}");
return(await stepContext.EndDialogAsync());
}
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
var dialog = this.ResolveDialog(dc);
// use bindingOptions to bind to the bound options
var boundOptions = BindOptions(dc, options);
if (this.IncludeActivity)
{
// reset this to false so that new dialog has opportunity to process the activity
dc.GetState().SetValue(TurnPath.ACTIVITYPROCESSED, false);
}
// replace dialog with bound options passed in as the options
return(await dc.ReplaceDialogAsync(dialog.Id, options : boundOptions, cancellationToken : cancellationToken).ConfigureAwait(false));
}
private async Task <DialogTurnResult> InterruptAsync(DialogContext innerDialogContext, CancellationToken cancellationToken)
{
if (innerDialogContext.Context.Activity.Type == ActivityTypes.Message &&
innerDialogContext.Context.Activity?.Text != null)
{
var text = innerDialogContext.Context.Activity.Text.ToLowerInvariant();
switch (text)
{
case "help":
case "?":
if (innerDialogContext.Stack != null && innerDialogContext.Stack.Count > 0)
{
var currentDialog = innerDialogContext.Stack[innerDialogContext.Stack.Count - 1]?.Id;
if (!string.IsNullOrWhiteSpace(currentDialog))
{
await innerDialogContext.Context.SendActivityAsync($"Show Help for {currentDialog}", cancellationToken : cancellationToken);
innerDialogContext.Context.Activity.Text = null;
return(await innerDialogContext.ReplaceDialogAsync(currentDialog, cancellationToken));
}
}
break;
case "cancel":
case "quit":
case "stop":
case "menu":
case "exit":
await innerDialogContext.Context.SendActivityAsync($"Cancelling...", cancellationToken : cancellationToken);
return(await innerDialogContext.CancelAllDialogsAsync());
}
}
return(null);
}
private async Task <DialogTurnResult> InterruptAsync(DialogContext innerDc, CancellationToken cancellationToken)
{
if (innerDc.Context.Activity.Type == ActivityTypes.Message)
{
string text = (string.IsNullOrEmpty(innerDc.Context.Activity.Text)) ? innerDc.Context.Activity.Value.ToString() : innerDc.Context.Activity.Text.ToLowerInvariant();
switch (text)
{
case "help":
case "volver":
//await innerDc.Context.SendActivityAsync($"Show Help...", cancellationToken: cancellationToken);
return(await innerDc.ReplaceDialogAsync(nameof(RootDialog), cancellationToken : cancellationToken));
case "cancel":
case "quit":
await innerDc.Context.SendActivityAsync($"Cancelling", cancellationToken : cancellationToken);
return(await innerDc.CancelAllDialogsAsync(cancellationToken : cancellationToken));
}
}
return(null);
}
/// <summary>
/// Called when the dialog is started and pushed onto the dialog stack.
/// </summary>
/// <param name="dc">The <see cref="DialogContext"/> for the current turn of conversation.</param>
/// <param name="options">Optional, initial information to pass to the dialog.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
if (this.Disabled != null && this.Disabled.GetValue(dc.State) == true)
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
lock (this.Condition)
{
if (this.caseExpressions == null)
{
this.caseExpressions = new Dictionary <string, Expression>();
foreach (var @case in this.Cases)
{
if (long.TryParse(@case.Value, out long intVal))
{
// you don't have to put quotes around numbers, "23" => 23 OR "23"
this.caseExpressions[@case.Value] = Expression.OrExpression(
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(intVal)),
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(@case.Value)));
}
else if (float.TryParse(@case.Value, out float floatVal))
{
// you don't have to put quotes around numbers, "23" => 23 OR "23"
this.caseExpressions[@case.Value] = Expression.OrExpression(
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(floatVal)),
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(@case.Value)));
}
else if (bool.TryParse(@case.Value, out bool boolVal))
{
// you don't have to put quotes around bools, "true" => true OR "true"
this.caseExpressions[@case.Value] = Expression.OrExpression(
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(boolVal)),
Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(@case.Value)));
}
else
{
// if someone does "=23" that will be numeric comparison or "='23'" that will be string comparison, or it can be a
// real expression bound to memory.
var(value, _) = new ValueExpression(@case.Value).TryGetValue(dc.State);
this.caseExpressions[@case.Value] = Expression.EqualsExpression(this.Condition, Expression.ConstantExpression(value));
}
}
}
}
ActionScope actionScope = this.DefaultScope;
foreach (var caseScope in this.Cases)
{
var(value, error) = this.caseExpressions[caseScope.Value].TryEvaluate(dc.State);
// Compare both expression results. The current switch case triggers if the comparison is true.
if (value != null && ((bool)value) == true)
{
actionScope = caseScope;
break;
}
}
return(await dc.ReplaceDialogAsync(actionScope.Id, null, cancellationToken : cancellationToken).ConfigureAwait(false));
}
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
var dcState = dc.GetState();
if (this.Disabled != null && this.Disabled.GetValue(dcState) == true)
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
lock (this.Condition)
{
if (this.caseExpressions == null)
{
this.caseExpressions = new Dictionary <string, Expression>();
foreach (var cse in this.Cases)
{
Expression caseExpression = null;
// Values for cases are always coerced to constant
if (long.TryParse(cse.Value, out long i))
{
caseExpression = Expression.ConstantExpression(i);
}
else if (float.TryParse(cse.Value, out float f))
{
caseExpression = Expression.ConstantExpression(f);
}
else if (bool.TryParse(cse.Value, out bool b))
{
caseExpression = Expression.ConstantExpression(b);
}
else
{
caseExpression = Expression.ConstantExpression(cse.Value);
}
var caseCondition = Expression.EqualsExpression(this.Condition, caseExpression);
// Map of expression to actions
this.caseExpressions[cse.Value] = caseCondition;
}
}
}
ActionScope actionScope = this.DefaultScope;
foreach (var caseScope in this.Cases)
{
var(value, error) = this.caseExpressions[caseScope.Value].TryEvaluate(dcState);
if (error != null)
{
throw new Exception($"Expression evaluation resulted in an error. Expression: {caseExpressions[caseScope.Value].ToString()}. Error: {error}");
}
// Compare both expression results. The current switch case triggers if the comparison is true.
if (((bool)value) == true)
{
actionScope = caseScope;
break;
}
}
return(await dc.ReplaceDialogAsync(actionScope.Id, null, cancellationToken : cancellationToken).ConfigureAwait(false));
}
public override async Task <DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)
{
var lastaskedquestion = await LastAskedAccessor.GetAsync(dc.Context, cancellationToken : cancellationToken);
switch (lastaskedquestion)
{
case "anythingelse":
{
var phraseType = Helper.GetPhraseType(dc.Context.Activity.Text);
switch (phraseType)
{
case PhraseType.Positive:
{
await LastAskedAccessor.DeleteAsync(dc.Context, cancellationToken : cancellationToken);
return(await dc.ReplaceDialogAsync(nameof(FoodOrderDialog), cancellationToken : cancellationToken));
}
case PhraseType.Negative:
{
//var cart = await Mediator.Send(new Application.Queries.ViewCartQuery(dc.Context.Activity.GetConversationReference()));
//if (cart != null && cart.NumberOfItems > 0)
//{
// await Helper.SendConfirmationPrompt("Do You want to checkout?", dc.Context, cancellationToken);
// await LastAskedAccessor.SetAsync(dc.Context, "wanttocheckout", cancellationToken: cancellationToken);
// return EndOfTurn;
//}
//else
//{
await dc.Context.SendActivityAsync("මට ඔබට සහය විය හැක්කේ කෙසේද ?", cancellationToken : cancellationToken);
return(await dc.EndDialogAsync(cancellationToken : cancellationToken));
//}
}
default:
{
await LastAskedAccessor.DeleteAsync(dc.Context, cancellationToken : cancellationToken);
await dc.CancelAllDialogsAsync(cancellationToken);
return(await dc.BeginDialogAsync(nameof(MainDialog), "no_intro_msg", cancellationToken : cancellationToken));
}
}
}
case "wanttocheckout":
{
var phraseType = Helper.GetPhraseType(dc.Context.Activity.Text);
switch (phraseType)
{
case PhraseType.Positive:
{
// return await dc.ReplaceDialogAsync(nameof(ViewCartDialog), cancellationToken: cancellationToken);
return(EndOfTurn);
}
case PhraseType.Negative:
{
await dc.Context.SendActivityAsync("Is there anything else I can do for you?", cancellationToken : cancellationToken);
return(await dc.EndDialogAsync(cancellationToken : cancellationToken));
}
default:
{
await dc.CancelAllDialogsAsync(cancellationToken);
return(await dc.BeginDialogAsync(nameof(MainDialog), "no_intro_msg", cancellationToken : cancellationToken));
}
}
}
default:
{
await LastAskedAccessor.DeleteAsync(dc.Context, cancellationToken : cancellationToken);
await dc.CancelAllDialogsAsync(cancellationToken);
return(await dc.BeginDialogAsync(nameof(MainDialog), "no_intro_msg", cancellationToken : cancellationToken));
}
}
return(EndOfTurn);
}
private async Task <bool> ExecuteActionsAsync(DialogContext dc, IEnumerable <CommandAction> actions)
{
var stateFlags = await _stateFlagsStateAccessor.GetAsync(dc.Context);
var inventoryItems = await _inventoryItemsAccessor.GetAsync(dc.Context);
// Get the room state. It always exists at this point because it's
// set up in the BeginDialogAsync method.
var roomStates = await _roomStateAccessor.GetAsync(dc.Context, () => new Dictionary <string, RoomState>());
var roomState = roomStates[_roomId];
var activities = new List <IActivity>();
var actionStack = new Stack <CommandAction>(actions.Reverse());
// Process each action in turn, populating the activities list.
while (actionStack.TryPop(out CommandAction nextAction))
{
switch (nextAction)
{
case AddToInventoryAction action:
{
if (!inventoryItems.Contains(action.InventoryItemId))
{
inventoryItems.Add(action.InventoryItemId);
activities.Add(_activityFactory.InventoryItemAdded(dc, action.InventoryItemId));
}
break;
}
case ClearFlagAction action:
{
if (stateFlags.Contains(action.Flag))
{
stateFlags.Remove(action.Flag);
}
break;
}
case GuiDelayAction action:
{
activities.Add(_activityFactory.Delayed(dc, action.Milliseconds));
break;
}
case GuiChangeActorDirectionAction action:
{
activities.Add(_activityFactory.ActorDirectionChanged(dc,
action.ActorId, action.Direction));
break;
}
case GuiMoveActorAction action:
{
// Save the actor's new position in the room state.
roomState.ActorPositions[action.ActorId] = action.Position;
activities.Add(_activityFactory.ActorMoved(dc, action.ActorId, action.Position));
break;
}
case GuiNarratorAction action:
{
activities.Add(_activityFactory.Narrated(dc, action.Text));
break;
}
case GuiPlaceActorAction action:
{
// Save the actor's new position in the room state.
roomState.ActorPositions[action.ActorId] = action.Position;
activities.Add(_activityFactory.ActorPlacedInRoom(dc, action.ActorId, action.Position));
break;
}
case GuiPlaceObjectAction action:
{
// Save the object's new position in the room state.
roomState.ObjectPositions[action.ObjectId] = action.Position;
activities.Add(_activityFactory.ObjectPlacedInRoom(dc, action.ObjectId, action.Position));
break;
}
case GuiRemoveObjectAction action:
{
// Remove the object from the room state.
roomState.ObjectPositions.Remove(action.ObjectId);
activities.Add(_activityFactory.ObjectRemovedFromRoom(dc, action.ObjectId));
break;
}
case RemoveFromInventoryAction action:
{
if (inventoryItems.Contains(action.InventoryItemId))
{
inventoryItems.Remove(action.InventoryItemId);
}
activities.Add(_activityFactory.InventoryItemRemoved(dc, action.InventoryItemId));
break;
}
case SetFlagAction action:
{
if (!stateFlags.Contains(action.Flag))
{
stateFlags.Add(action.Flag);
}
break;
}
case SpeakAction action:
{
activities.Add(_activityFactory.Speak(dc, action.ActorId, action.Text));
break;
}
case StartConversationAction action:
{
// If the result of the action indicates that we need to start a new dialog
// (e.g. conversation with an actor, or a switch to a new room), first send all
// activities collected up to this point to the client.
if (activities.Any())
{
await dc.Context.SendActivitiesAsync(activities.ToArray());
}
// If the player starts a conversation, save any remaining actions to the state.
// These will be executed when the conversation is done and this dialog
// continues.
if (actionStack.Any())
{
// Conver to List because Stacks don't serialize in the correct order.
// See https://github.com/JamesNK/Newtonsoft.Json/issues/971.
dc.ActiveDialog.State.Add(DialogStatePendingActions, actionStack.ToList());
}
// Start the conversation.
await dc.BeginDialogAsync(action.ConversationId);
// Stop processing any further actions now that we've switched to a new dialog.
return(false);
}
case SwitchRoomAction action:
{
// If the result of the action indicates that we need to start a new dialog
// (e.g. conversation with an actor, or a switch to a new room), first send all
// activities collected up to this point to the client.
if (activities.Any())
{
await dc.Context.SendActivitiesAsync(activities.ToArray());
}
// Switch to the new room.
await dc.ReplaceDialogAsync(action.RoomId);
// Stop processing any further actions now that we've switched to a new dialog.
return(false);
}
case TextDescribeAction action:
{
activities.Add(MessageFactory.Text(action.Text));
break;
}
}
}
await dc.Context.SendActivitiesAsync(activities.ToArray());
// Returning true here indicates that we can continue processing the actions for this turn.
return(true);
}