/// <summary> /// Creates a turn context and runs the middleware pipeline for an incoming activity. /// </summary> /// <param name="authHeader">The HTTP authentication header of the request.</param> /// <param name="activity">The incoming activity.</param> /// <param name="callback">The code to run at the end of the adapter's middleware /// pipeline.</param> /// <returns>A task that represents the work queued to execute.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="activity"/> is <c>null</c>.</exception> /// <exception cref="UnauthorizedAccessException"> /// authentication failed.</exception> /// <remarks>Call this method to reactively send a message to a conversation. /// <para>This method registers the following services for the turn.<list type="bullet"> /// <item><see cref="IIdentity"/> (key = "BotIdentity"), a claims identity for the bot.</item> /// <item><see cref="IConnectorClient"/>, the channel connector client to use this turn.</item> /// </list></para> /// </remarks> /// <seealso cref="ContinueConversation(string, ConversationReference, Func{ITurnContext, Task})"/> /// <seealso cref="BotAdapter.RunPipeline(ITurnContext, Func{ITurnContext, Task}, System.Threading.CancellationTokenSource)"/> public async Task ProcessActivity(string authHeader, Activity activity, Func <ITurnContext, Task> callback) { BotAssertSlack.ActivityNotNull(activity); var claimsIdentity = await JwtTokenValidation.AuthenticateRequest(activity, authHeader, _credentialProvider, _httpClient); var context = new TurnContext(this, activity); context.Services.Add <IIdentity>("BotIdentity", claimsIdentity); var connectorClient = await this.CreateConnectorClientAsync(activity.ServiceUrl, claimsIdentity); context.Services.Add <IConnectorClient>(connectorClient); await base.RunPipeline(context, callback).ConfigureAwait(false); }
/// <summary> /// Send a reply with the template /// </summary> /// <param name="context"></param> /// <param name="language"></param> /// <param name="templateId"></param> /// <param name="data"></param> /// <returns></returns> public async Task ReplyWith(ITurnContext context, string templateId, object data = null) { BotAssertSlack.ContextNotNull(context); // apply template Activity boundActivity = await this.RenderTemplate(context, context.Activity?.AsMessageActivity()?.Locale, templateId, data).ConfigureAwait(false); if (boundActivity != null) { await context.SendActivity(boundActivity); return; } return; }
public async Task <IList <Intent> > Recognize(ITurnContext context) { BotAssertSlack.ContextNotNull(context); bool isEnabled = await IsRecognizerEnabled(context).ConfigureAwait(false); if (isEnabled) { var allRecognizedIntents = await RunRecognizer(context).ConfigureAwait(false); await RunFilters(context, allRecognizedIntents); return(allRecognizedIntents); } else { return(new List <Intent>()); } }
protected async Task RunPipeline(ICommandContext context, Func <ICommandContext, Task> callback = null, CancellationTokenSource cancelToken = null) { BotAssertSlack.ContextNotNull(context); // Call any registered Middleware Components looking for ReceiveActivity() if (context.Command != null) { await _middlewareSet.ReceiveActivityWithStatus(context, callback).ConfigureAwait(false); } else { // call back to caller on proactive case if (callback != null) { await callback(context).ConfigureAwait(false); } } }
public async Task OnTurn(ITurnContext context, MiddlewareSet.NextDelegate next) { BotAssertSlack.ContextNotNull(context); var intents = await this.Recognize(context); var result = new IntentRecognition(); if (intents.Count != 0) { result.Intents = intents; var topIntent = FindTopIntent(intents); if (topIntent.Score > 0.0) { result.TopIntent = topIntent; } } context.Services.Add((IRecognizedIntents)result); await next().ConfigureAwait(false); }