protected virtual Task <PromptRecognizerResult <Activity> > OnRecognizeAsync(ITurnContext context, IDictionary <string, object> state, PromptOptions options)
{
return(Task.FromResult(new PromptRecognizerResult <Activity>
{
Succeeded = true,
Value = context.Activity,
}));
}
protected abstract Task OnPromptAsync(DialogContext dc, PromptOptions options, bool isRetry);
protected override Task <PromptRecognizerResult <FoundChoice> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options)
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var choices = options.Choices ?? new List <Choice>();
var result = new PromptRecognizerResult <FoundChoice>();
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var activity = turnContext.Activity;
var utterance = activity.Text;
var opt = RecognizerOptions ?? new FindChoicesOptions();
opt.Locale = activity.Locale ?? opt.Locale ?? DefaultLocale ?? English;
var results = ChoiceRecognizers.RecognizeChoices(utterance, choices, opt);
if (results != null && results.Count > 0)
{
result.Succeeded = true;
result.Value = results[0].Resolution;
}
}
return(Task.FromResult(result));
}
/// <summary> Constructor for a prompt int64 dialog. </summary>
/// <param name="promptOptions"> THe prompt options.</param>
public PromptInt64(PromptOptions <long> promptOptions)
: base(promptOptions)
{
}
/// <summary>
/// Constructs a choice dialog.
/// </summary>
/// <param name="promptOptions"> The prompt options</param>
public PromptChoice(PromptOptions <T> promptOptions)
: base(promptOptions)
{
SetField.CheckNull(nameof(promptOptions.Options), promptOptions.Options);
}
protected abstract Task <PromptRecognizerResult <T> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options);
/// <summary>
/// Prompt for one of a set of choices.
/// </summary>
/// <remarks><typeparamref name="T"/> should implement <see cref="object.ToString"/></remarks>
/// <typeparam name="T"> The type of the options.</typeparam>
/// <param name="context"> The dialog context.</param>
/// <param name="resume"> Resume handler.</param>
/// <param name="promptOptions"> The prompt options.</param>
public static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, PromptOptions <T> promptOptions)
{
var child = new PromptChoice <T>(promptOptions);
context.Call <T>(child, resume);
}
protected override Task <PromptRecognizerResult <IList <Attachment> > > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var result = new PromptRecognizerResult <IList <Attachment> >();
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var message = turnContext.Activity.AsMessageActivity();
if (message.Attachments != null && message.Attachments.Count > 0)
{
result.Succeeded = true;
result.Value = message.Attachments;
}
}
return(Task.FromResult(result));
}
protected virtual async Task OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.Prompt != null)
{
await turnContext.SendActivityAsync(options.Prompt, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Attempts to recognize the user's input.
/// </summary>
/// <param name="turnContext">Context for the current turn of conversation with the user.</param>
/// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param>
/// <param name="options">A prompt options object constructed from the options initially provided
/// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</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>
/// <remarks>If the task is successful, the result describes the result of the recognition attempt.</remarks>
protected override Task <PromptRecognizerResult <T> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var result = new PromptRecognizerResult <T>();
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var message = turnContext.Activity.AsMessageActivity();
var culture = turnContext.Activity.Locale ?? DefaultLocale ?? English;
var results = RecognizeNumberWithUnit(message.Text, culture);
if (results.Count > 0)
{
// Try to parse value based on type
string text = string.Empty;
// Try to parse value based on type
var valueResolution = results[0].Resolution["value"];
if (valueResolution != null)
{
text = valueResolution.ToString();
}
if (typeof(T) == typeof(float))
{
if (float.TryParse(text, NumberStyles.Any, new CultureInfo(culture), out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(int))
{
if (int.TryParse(text, NumberStyles.Any, new CultureInfo(culture), out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(long))
{
if (long.TryParse(text, NumberStyles.Any, new CultureInfo(culture), out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(double))
{
if (double.TryParse(text, NumberStyles.Any, new CultureInfo(culture), out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(decimal))
{
if (decimal.TryParse(text, NumberStyles.Any, new CultureInfo(culture), out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
}
}
return(Task.FromResult(result));
}
/// <summary> /// When overridden in a derived class, prompts the user for input. /// </summary> /// <param name="turnContext">Context for the current turn of conversation with the user.</param> /// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param> /// <param name="options">A prompt options object constructed from the options initially provided /// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</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 virtual async Task OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken)) => await OnPromptAsync(turnContext, state, options, false, cancellationToken).ConfigureAwait(false);
protected override Task <PromptRecognizerResult <IList <DateTimeResolution> > > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var result = new PromptRecognizerResult <IList <DateTimeResolution> >();
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var message = turnContext.Activity.AsMessageActivity();
var culture = turnContext.Activity.Locale ?? DefaultLocale ?? English;
var results = DateTimeRecognizer.RecognizeDateTime(message.Text, culture);
if (results.Count > 0)
{
// Return list of resolutions from first match
result.Succeeded = true;
result.Value = new List <DateTimeResolution>();
var values = (List <Dictionary <string, string> >)results[0].Resolution["values"];
foreach (var value in values)
{
result.Value.Add(ReadResolution(value));
}
}
}
return(Task.FromResult(result));
}
/// <summary>
/// Attempts to recognize the user's input.
/// </summary>
/// <param name="turnContext">Context for the current turn of conversation with the user.</param>
/// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param>
/// <param name="options">A prompt options object constructed from the options initially provided
/// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</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>
/// <remarks>If the task is successful, the result describes the result of the recognition attempt.</remarks>
protected override Task <PromptRecognizerResult <T> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var result = new PromptRecognizerResult <T>();
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var message = turnContext.Activity.AsMessageActivity();
var culture = turnContext.Activity.Locale ?? DefaultLocale ?? English;
var results = NumberRecognizer.RecognizeNumber(message.Text, culture);
if (results.Count > 0)
{
// Try to parse value based on type
var text = results[0].Resolution["value"].ToString();
if (typeof(T) == typeof(float))
{
if (float.TryParse(text, out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(int))
{
if (int.TryParse(text, out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(long))
{
if (long.TryParse(text, out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(double))
{
if (double.TryParse(text, out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else if (typeof(T) == typeof(decimal))
{
if (decimal.TryParse(text, out var value))
{
result.Succeeded = true;
result.Value = (T)(object)value;
}
}
else
{
throw new NotSupportedException($"NumberPrompt: type argument T of type 'typeof(T)' is not supported");
}
}
}
return(Task.FromResult(result));
}
protected override async Task OnPromptAsync(ITurnContext context, IDictionary <string, object> state, PromptOptions options, bool isRetry)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (isRetry && options.RetryPrompt != null)
{
await context.SendActivityAsync(options.RetryPrompt).ConfigureAwait(false);
}
else if (options.Prompt != null)
{
await context.SendActivityAsync(options.Prompt).ConfigureAwait(false);
}
}
/// <summary>
/// Called when a prompt dialog is pushed onto the dialog stack and is being activated.
/// </summary>
/// <param name="dc">The dialog context for the current turn of the conversation.</param>
/// <param name="options">Optional, additional information to pass to the prompt being started.</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>
/// <remarks>If the task is successful, the result indicates whether the prompt is still
/// active after the turn has been processed by the prompt.</remarks>
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (dc == null)
{
throw new ArgumentNullException(nameof(dc));
}
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
PromptOptions opt = null;
if (options != null)
{
if (options is PromptOptions)
{
// Ensure prompts have input hint set
opt = options as PromptOptions;
if (opt.Prompt != null && string.IsNullOrEmpty(opt.Prompt.InputHint))
{
opt.Prompt.InputHint = InputHints.AcceptingInput;
}
if (opt.RetryPrompt != null && string.IsNullOrEmpty(opt.RetryPrompt.InputHint))
{
opt.RetryPrompt.InputHint = InputHints.AcceptingInput;
}
}
else
{
throw new ArgumentException(nameof(options));
}
}
// Initialize state
var timeout = _settings.Timeout ?? (int)TurnStateConstants.OAuthLoginTimeoutValue.TotalMilliseconds;
var state = dc.ActiveDialog.State;
state[PersistedOptions] = opt;
state[PersistedState] = new Dictionary <string, object>
{
{ Prompt <int> .AttemptCountKey, 0 },
};
state[PersistedExpires] = DateTime.Now.AddMilliseconds(timeout);
// Attempt to get the users token
if (!(dc.Context.Adapter is IExtendedUserTokenProvider adapter))
{
throw new InvalidOperationException("OAuthPrompt.Recognize(): not supported by the current adapter");
}
var output = await adapter.GetUserTokenAsync(dc.Context, _settings.OAuthAppCredentials, _settings.ConnectionName, null, cancellationToken).ConfigureAwait(false);
if (output != null)
{
// Return token
return(await dc.EndDialogAsync(output, cancellationToken).ConfigureAwait(false));
}
// Prompt user to login
await SendOAuthCardAsync(dc.Context, opt?.Prompt, cancellationToken).ConfigureAwait(false);
return(EndOfTurn);
}
protected virtual Task <PromptRecognizerResult <Activity> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.FromResult(new PromptRecognizerResult <Activity>
{
Succeeded = true,
Value = turnContext.Activity,
}));
}
protected abstract Task OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, bool isRetry);
protected override async Task <ConfirmResult> OnRecognizeAsync(DialogContext dc, PromptOptions options)
{
if (dc == null)
{
throw new ArgumentNullException(nameof(dc));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(await _prompt.RecognizeAsync(dc.Context).ConfigureAwait(false));
}
/// <summary>
/// Ask a yes/no questions.
/// </summary>
/// <param name="context"> The dialog context.</param>
/// <param name="resume"> Resume handler.</param>
/// <param name="promptOptions"> The options for the prompt, <see cref="PromptOptions{T}"/>.</param>
public static void Confirm(IDialogContext context, ResumeAfter <bool> resume, PromptOptions <string> promptOptions)
{
var child = new PromptConfirm(promptOptions);
context.Call <bool>(child, resume);
}
internal PromptValidatorContext(DialogContext dc, IDictionary <string, object> state, PromptOptions options, PromptRecognizerResult <T> recognized)
{
_dc = dc;
HasEnded = false;
EndResult = null;
Options = options;
Recognized = recognized;
}
/// <summary>
/// Constructor for a prompt confirmation dialog.
/// </summary>
/// <param name="promptOptions"> THe prompt options.</param>
public PromptConfirm(PromptOptions <string> promptOptions)
: base(promptOptions)
{
this.promptOptions.DefaultRetry = this.DefaultRetry;
}
/// <summary> /// When overridden in a derived class, prompts the user for input. /// </summary> /// <param name="turnContext">Context for the current turn of conversation with the user.</param> /// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param> /// <param name="options">A prompt options object constructed from the options initially provided /// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</param> /// <param name="isRetry">true if this is the first time this prompt dialog instance /// on the stack is prompting the user for input; otherwise, false.</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 abstract Task OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, bool isRetry, CancellationToken cancellationToken = default);
/// <summary> Constructor for a prompt double dialog. </summary>
/// <param name="promptOptions"> THe prompt options.</param>
public PromptDouble(PromptOptions <double> promptOptions)
: base(promptOptions)
{
}
/// <summary> /// When overridden in a derived class, attempts to recognize the user's input. /// </summary> /// <param name="turnContext">Context for the current turn of conversation with the user.</param> /// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param> /// <param name="options">A prompt options object constructed from the options initially provided /// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</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> /// <remarks>If the task is successful, the result describes the result of the recognition attempt.</remarks> protected abstract Task <PromptRecognizerResult <T> > OnRecognizeAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, CancellationToken cancellationToken = default);
protected override async Task <AttachmentResult> OnRecognize(DialogContext dc, PromptOptions options)
{
if (dc == null)
{
throw new ArgumentNullException(nameof(dc));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(await _prompt.Recognize(dc.Context));
}
internal PromptValidatorContext(ITurnContext turnContext, PromptRecognizerResult <T> recognized, IDictionary <string, object> state, PromptOptions options)
{
Context = turnContext;
Options = options;
Recognized = recognized;
State = state;
}
protected abstract Task <T> OnRecognizeAsync(DialogContext dc, PromptOptions options);
/// <summary>
/// Prompts the user for input.
/// </summary>
/// <param name="turnContext">Context for the current turn of conversation with the user.</param>
/// <param name="state">Contains state for the current instance of the prompt on the dialog stack.</param>
/// <param name="options">A prompt options object constructed from the options initially provided
/// in the call to <see cref="DialogContext.PromptAsync(string, PromptOptions, CancellationToken)"/>.</param>
/// <param name="isRetry">true if this is the first time this prompt dialog instance
/// on the stack is prompting the user for input; otherwise, false.</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 OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, bool isRetry, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var culture = DetermineCulture(turnContext.Activity);
// Format prompt to send
IMessageActivity prompt;
var choices = options.Choices ?? new List <Choice>();
var channelId = turnContext.Activity.ChannelId;
var choiceOptions = ChoiceOptions ?? _choiceDefaults[culture];
var choiceStyle = options.Style ?? Style;
if (isRetry && options.RetryPrompt != null)
{
prompt = AppendChoices(options.RetryPrompt, channelId, choices, choiceStyle, choiceOptions);
}
else
{
prompt = AppendChoices(options.Prompt, channelId, choices, choiceStyle, choiceOptions);
}
// Send prompt
await turnContext.SendActivityAsync(prompt, cancellationToken).ConfigureAwait(false);
}
protected override async Task OnPromptAsync(ITurnContext turnContext, IDictionary <string, object> state, PromptOptions options, bool isRetry)
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
// Determine culture
var culture = turnContext.Activity.Locale ?? DefaultLocale;
if (string.IsNullOrEmpty(culture) || !DefaultChoiceOptions.ContainsKey(culture))
{
culture = English;
}
// Format prompt to send
IMessageActivity prompt;
var choices = options.Choices ?? new List <Choice>();
var channelId = turnContext.Activity.ChannelId;
var choiceOptions = ChoiceOptions ?? DefaultChoiceOptions[culture];
if (isRetry && options.RetryPrompt != null)
{
prompt = AppendChoices(options.RetryPrompt, channelId, choices, Style, choiceOptions);
}
else
{
prompt = AppendChoices(options.Prompt, channelId, choices, Style, choiceOptions);
}
// Send prompt
await turnContext.SendActivityAsync(prompt).ConfigureAwait(false);
}
protected virtual async Task OnPromptAsync(ITurnContext context, IDictionary <string, object> state, PromptOptions options)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.Prompt != null)
{
await context.SendActivityAsync(options.Prompt).ConfigureAwait(false);
}
}
