public void Call <R>(IDialog <R> child, ResumeAfter <R> resume)
{
if (child is EditablePromptChoice <string> p)
{
var language = _translatorService.GetLanguage(_original);
if (string.IsNullOrWhiteSpace(language))
{
_original.Call <R>(child, resume);
return;
}
var optOld = p.PromptOptions;
var prompt = AsyncHelpers.RunSync(() => _translatorService.Translate(optOld.Prompt, "en", language));
var retry = AsyncHelpers.RunSync(() => _translatorService.Translate(optOld.Retry, "en", language));
var optNew = new PromptOptions <string>(prompt, retry, optOld.TooManyAttempts, optOld.Options, optOld.Attempts, optOld.PromptStyler, optOld.Descriptions);
var newDialog = new PromptDialog.PromptChoice <string>(optNew);
_original.Call <string>(newDialog, resume as ResumeAfter <string>);
return;
}
_original.Call <R>(child, resume);
}
public async Task GetIntent(ResumeAfter <object> messageReceivedAsync, Activity activity, IDialogContext context, object obj = null)
{
var message = activity.Text.ToLower();
var luis = await Rest.LUIS.GetAsync(message.Replace("-", null));
string topScoringIntent = luis.topScoringIntent.intent.ToLower();
if (topScoringIntent == "quiz")
{
await context.Forward(new QuizDialog(), messageReceivedAsync, activity, CancellationToken.None);
}
else if (topScoringIntent == "greeting")
{
await context.Forward(new InitDialog(), messageReceivedAsync, activity, CancellationToken.None);
}
else if (topScoringIntent == "thanks")
{
await context.Forward(new ThanksDialog(), messageReceivedAsync, activity, CancellationToken.None);
}
else
{
await context.Forward(new NoneDialog(), messageReceivedAsync, activity, CancellationToken.None);
}
}
public static async Task RequiresAuthentication(this IDialogContext context, ResumeAfter <bool> resumeAfter, string loginOperationDescription = "carry out this operation")
{
if (resumeAfter == null)
{
throw new ArgumentNullException(nameof(resumeAfter));
}
var dialog = GetLoginDialog();
if (dialog != null)
{
dialog.LoginRequiredMessage = $"You are required to login before you can {loginOperationDescription}.";
dialog.LoginOperationDescription = loginOperationDescription;
dialog.RequiredRoles = new string[] { };
}
if (!context.IsAuthenticated())
{
if (dialog != null)
{
context.Call(
dialog,
resumeAfter
);
}
else
{
await resumeAfter(context, new MockupAwaitable <bool>(false));
}
}
else
{
await resumeAfter(context, new MockupAwaitable <bool>(true));
}
}
// Choice
public static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IPromptOptions <T> promptOptions, bool isAdaptiveCard = true, PromptStyle promptStyle = PromptStyle.Auto, bool recognizeChoices = true, bool recognizeNumbers = true, bool recognizeOrdinals = true, double minScore = 0.4)
{
IPromptOptions <T> adPromptOptions;
if (promptOptions.GetType() == typeof(PromptOptions <T>))
{
adPromptOptions = new PromptOptions <T>(promptOptions.Prompt,
promptOptions.Retry,
attempts: promptOptions.Attempts,
options: promptOptions.Options.ToList(),
promptStyler: new AdaptivePromptStyler(promptStyle, isAdaptiveCard),
descriptions: promptOptions.Descriptions?.ToList());
}
else
{
adPromptOptions = new PromptOptionsWithSynonyms <T>(promptOptions.Prompt,
promptOptions.Retry,
attempts: promptOptions.Attempts,
choices: promptOptions.Choices.ToDictionary(x => x.Key,
x => (IReadOnlyList <T>)x.Value.ToList().AsReadOnly()),
promptStyler: new AdaptivePromptStyler(promptStyle, isAdaptiveCard),
descriptions: promptOptions.Descriptions?.ToList());
}
PromptDialog.Choice(context, resume, adPromptOptions, recognizeChoices, recognizeNumbers, recognizeOrdinals, minScore);
}
/// <summary> Prompt for one of a set of choices. </summary>
/// <param name="context"> The context. </param>
/// <param name="resume"> Resume handler. </param>
/// <param name="options"> The possible options all of which must be convertible to a string.</param>
/// <param name="prompt"> The prompt to show to the user. </param>
/// <param name="retry"> What to show on retry. </param>
/// <param name="attempts"> The number of times to retry. </param>
/// <param name="promptStyle"> Style of the prompt <see cref="PromptStyle" /> </param>
/// <param name="descriptions">Descriptions to display for choices.</param>
public static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IEnumerable <T> options, string prompt, string retry = null, int attempts = 3, PromptStyle promptStyle = PromptStyle.Auto, IEnumerable <string> descriptions = null)
{
List <T> l_options = options.ToList();
Shuffle(ref l_options);
Choice(context, resume, new PromptOptions <T>(prompt, retry, attempts: attempts, options: l_options, promptStyler: new PromptStyler(promptStyle), descriptions: descriptions?.ToList()));
}
// Wait
public async Task Wait <T>(ResumeAfter <T> resumeAfter)
{
await StartAsync((context) =>
{
context.Task.Wait(resumeAfter);
}, CancellationToken.None);
}
public static void Choice(IDialogContext context, ResumeAfter <T> resume,
CancelablePromptOptions <T> promptOptions)
{
var child = new CancelablePromptChoice <T>(promptOptions);
context.Call(child, resume);
}
private void RegisterResultHandler <U>(Command command, ResumeAfter <U> resultHandler)
{
if (resultHandler != null)
{
resultHandlers.Add(command.CommandId, resultHandler);
}
}
public async Task <bool> checkOutdatedMessage <R>(IDialogContext context, ResumeAfter <R> resume, IAwaitable <IMessageActivity> message)
{
updateUserSession(context);
var mes = await message;
if (mes.Text.Length == 0)
{
return(false);
}
if (mes.Timestamp <= Request)
{
// mes.Summary = getDialogContext();
context.Wait(resume);
//await context.Forward<IMessageActivity, IMessageActivity>(new SideDialog(), resume, mes, CancellationToken.None);
return(true);
}
else if (context.Activity.Timestamp >= Request.AddHours(1))
{
await writeMessageToUser(context, conv().getPhrase(Pkey.whereDidYouGone));
context.ConversationData.SetValue <ResumeAfter <R> >("resume", resume);
// await context.Forward<bool,string[]>(new YesNoQuestionDialog(), continuFromLastPlace, conv().getPhrase(Pkey.youWantToContinue),new CancellationToken());
}
return(false);
}
public new static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IEnumerable <T> options, string prompt, string retry = null, int attempts = 3, PromptStyle promptStyle = PromptStyle.Auto, IEnumerable <string> descriptions = null)
{
if (!(context is TranslatingDialogContext))
{
context = new TranslatingDialogContext(context);
}
Choice(context, resume, new PromptOptions <T>(prompt, retry, attempts: attempts, options: options.ToList(), promptStyler: new PromptStyler(promptStyle), descriptions: descriptions?.ToList()));
}
public static void Choice(IDialogContext context, ResumeAfter <T> resume, IEnumerable <T> options, string prompt,
string cancelPrompt = null, string retry = null, int attempts = 3,
PromptStyle promptStyle = PromptStyle.Auto)
{
Choice(context, resume,
new CancelablePromptOptions <T>(prompt, cancelPrompt, retry, attempts : attempts,
options : options.ToList(), promptStyler : new PromptStyler(promptStyle)));
}
/// <summary> Define the default action if no match. </summary>
/// <param name="handler"> Handler to call if no match. </param>
/// <returns> A CommandDialog. </returns>
#endregion
public CommandDialog OnDefault(ResumeAfter <Connector.Message> handler)
{
var command = new Command {
CommandHandler = handler
};
this.defaultCommand = command;
return(this);
}
// Forward Dialog
public async Task Forward(IDialog <object> dialog, ResumeAfter <object> resumeAfter = null)
{
await StartAsync(async (context) =>
{
var interruption = dialog.Void <object, IMessageActivity>();
await context.Task.Forward(interruption, resumeAfter, Activity, CancellationToken.None);
await context.Task.PollAsync(CancellationToken.None);
}, CancellationToken.None);
}
async Task IDialogStack.Forward <R, T>(IDialog <R> child, ResumeAfter <R> resume, T item, CancellationToken token)
{
IDialogStack stack = this;
stack.Call(child, resume);
await stack.PollAsync(token);
await(this as IPostToBot).PostAsync(item, token);
}
public static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IEnumerable <T> options, string prompt, string retry = null, int attempts = 3, bool isAdaptiveCard = true, PromptStyle promptStyle = PromptStyle.Auto, IEnumerable <string> descriptions = null)
{
var adPromptOptions = new PromptOptions <T>(prompt, retry, attempts: attempts,
options: options.ToList(),
promptStyler: new AdaptivePromptStyler(promptStyle, isAdaptiveCard),
descriptions: descriptions?.ToList());
PromptDialog.Choice(context, resume, adPromptOptions);
}
public static void Confirm(IDialogContext context, ResumeAfter <bool> resume, string prompt, string retry = null, int attempts = 3, bool isAdaptiveCard = true, PromptStyle promptStyle = PromptStyle.Auto, string[] options = null, string[][] patterns = null)
{
var adPromptOptions = new PromptOptions <string>(prompt,
retry,
attempts: attempts,
options: options ?? PromptDialog.PromptConfirm.Options,
promptStyler: new AdaptivePromptStyler(promptStyle, isAdaptiveCard));
PromptDialog.Confirm(context, resume, adPromptOptions, patterns);
}
public static async Task CreateReply(ResumeAfter <IMessageActivity> resume, IDialogContext context, Activity activity, string message)
{
var reply = activity.CreateReply(message);
reply.Type = ActivityTypes.Message;
reply.TextFormat = TextFormatTypes.Plain;
await context.PostAsync(reply);
context.Wait(resume);
}
/// <summary> Define the default action if no match. </summary>
/// <typeparam name="U"> Type of input to result handler. </typeparam>
/// <param name="handler"> Handler to call if no match. </param>
/// <param name="resultHandler"> Optional result handler to be called if handler is creating a chaild dialog. </param>
/// <returns> A CommandDialog. </returns>
#endregion
public CommandDialog <T> OnDefault <U>(ResumeAfter <Connector.IMessageActivity> handler, ResumeAfter <U> resultHandler = null)
{
var command = new Command {
CommandId = "defaultResultHandler", CommandHandler = handler
};
this.defaultCommand = command;
RegisterResultHandler(command, resultHandler);
return(this);
}
private async Task GetIssue(IDialogContext context, ResumeAfter <double> resume)
{
if (_lastIssue == 0)
{
PromptDialog.Number(context, resume, "What issue are you referring to?", "I didn't catch that...try again?");
}
else
{
await resume(context, Awaitable.FromItem((double)_lastIssue));
}
}
/// <summary> Define a handler that is fired on a regular expression match of a message. </summary>
/// <param name="expression"> Regular expression to match. </param>
/// <param name="handler"> Handler to call on match. </param>
/// <returns> A CommandDialog. </returns>
#endregion
public CommandDialog On(Regex expression, ResumeAfter <Connector.Message> handler)
{
var command = new Command
{
Expression = expression,
CommandHandler = handler,
};
commands.Add(command);
return(this);
}
public void ConfirmDialog(IDialogContext context, ResumeAfter <bool> executeAfterUserResponse, string promptMessage, string retryMessage = "", int attemptsAllowed = 3, PromptStyle style = PromptStyle.Auto)
{
PromptDialog.Confirm(
context: context,
resume: executeAfterUserResponse,
prompt: promptMessage,
retry: retryMessage.HasValue() ? retryMessage : defaultRetryMessage,
attempts: attemptsAllowed,
promptStyle: style
);
}
public static void Choice(IDialogContext context, ResumeAfter <T> resume,
IEnumerable <T> options, IEnumerable <T> validOptions,
string prompt, string retry = null, string tooManyAttempts = null,
int attempts = 3, PromptStyle promptStyle = PromptStyle.Auto)
{
Choice(context, resume, new FuzzyPromptOptions <T>(
prompt, retry, tooManyAttempts,
attempts : attempts, options : options.ToList(),
validOptions : validOptions.ToList(),
promptStyler : new PromptStyler(promptStyle)));
}
private void HandleMultiAddress(IDialogContext context, BaseRequest request, ResumeAfter <string> onMultiAddressTask)
{
string multiAddressMessage = $"I narrowed down {request.AddressesArray.Length} possible locations. Please choose one below.";
List <string> list = new List <string>(request.AddressesArray)
{
"None"
};
context.UserData.Replace(request.Key, request);
PromptDialog.Choice(context, onMultiAddressTask, list, multiAddressMessage);
}
public static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IDictionary <T, IEnumerable <T> > choices, string prompt, string retry = null, int attempts = 3, bool isAdaptiveCard = true, PromptStyle promptStyle = PromptStyle.Auto, IEnumerable <string> descriptions = null, bool recognizeChoices = true, bool recognizeNumbers = true, bool recognizeOrdinals = true, double minScore = 0.4)
{
var adPromptOptions = new PromptOptionsWithSynonyms <T>(prompt,
retry,
attempts: attempts,
choices: choices.ToDictionary(x => x.Key,
x => (IReadOnlyList <T>)x.Value.ToList().AsReadOnly()),
promptStyler: new AdaptivePromptStyler(promptStyle, isAdaptiveCard),
descriptions: descriptions?.ToList());
PromptDialog.Choice(context, resume, adPromptOptions, recognizeChoices, recognizeNumbers, recognizeOrdinals, minScore);
}
public new static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, PromptOptions <T> promptOptions)
{
if (!(context is TranslatingDialogContext))
{
context = new TranslatingDialogContext(context);
}
var child = new EditablePromptChoice <T>(promptOptions);
var cp = new ResumeReplacer <T>(resume);
context.Call <T>(child, cp.ResumeReplace);
}
/// <summary> Define a handler that is fired on a regular expression match of a message. </summary>
/// <typeparam name="U"> Type of input to result handler. </typeparam>
/// <param name="expression"> Regular expression to match. </param>
/// <param name="handler"> Handler to call on match. </param>
/// <param name="resultHandler"> Optional result handler to be called if handler is creating a chaild dialog. </param>
/// <returns> A commandDialog. </returns>
#endregion
public CommandDialog <T> On <U>(Regex expression, ResumeAfter <Connector.IMessageActivity> handler, ResumeAfter <U> resultHandler = null)
{
var command = new Command
{
CommandId = ComputeHash(expression.ToString()),
Expression = expression,
CommandHandler = handler,
};
commands.Add(command);
RegisterResultHandler(command, resultHandler);
return(this);
}
void IDialogStack.Call <R>(IDialog <R> child, ResumeAfter <R> resume)
{
var callRest = ToRest(child.StartAsync);
if (resume != null)
{
var doneRest = ToRest(resume);
this.wait = this.fiber.Call <DialogTask, object, R>(callRest, null, doneRest);
}
else
{
this.wait = this.fiber.Call <DialogTask, object>(callRest, null);
}
}
private async Task GetRepo(IDialogContext context, string token, ResumeAfter <string> resume)
{
if (string.IsNullOrEmpty(_lastRepo))
{
IReadOnlyList <Repository> list = await GitHubCommands.GetRepoList(token, string.Empty);
IEnumerable <string> repos = list.Select(i => i.Name);
PromptDialog.Choice(context, resume, repos, "Which repo are you asking about?", "I didn't catch that...try again?");
}
else
{
await resume(context, Awaitable.FromItem(_lastRepo));
}
}
async Task IDialogStack.Forward <R, T>(IDialog <R> child, ResumeAfter <R> resume, T item, CancellationToken token)
{
// put the child on the stack
IDialogStack stack = this;
stack.Call(child, resume);
// run the loop
IEventLoop loop = this;
await loop.PollAsync(token);
// forward the item
this.fiber.Post(item);
// run the loop again
await loop.PollAsync(token);
}
public async Task None(IDialogContext context, LuisResult result)
{
await context.PostAsync($"What does {result.Query} mean?");
ResumeAfter <object> processDontKnow = async(c, s) =>
{
await s;
var messages = new[] { "I don't think I needed to know that", "I'm not sure that's useful", "Actually, I don't care", "Whatever", "That's not very interesting", "Let's just put that on the back burner" };
await c.PostAsync(messages[random.Next(messages.Length)]);
c.Wait(this.MessageReceived);
};
context.Wait(processDontKnow);
}
/// <summary>
/// Suspend the current dialog until the user has sent a message to the bot.
/// </summary>
/// <param name="stack">The dialog stack.</param>
/// <param name="resume">The method to resume when the message has been received.</param>
public static void Wait(this IDialogStack stack, ResumeAfter<Message> resume)
{
stack.Wait<Message>(resume);
}
/// <summary>
/// Suspend the current dialog until the user has sent a message to the bot.
/// </summary>
/// <param name="stack">The dialog stack.</param>
/// <param name="resume">The method to resume when the message has been received.</param>
public static void Wait(this IDialogStack stack, ResumeAfter<IMessageActivity> resume)
{
stack.Wait<IMessageActivity>(resume);
}
