private TestFlow CreateNoResourceExplorerFlow(BotCallbackHandler handler) { var storage = new MemoryStorage(); var convoState = new ConversationState(storage); var userState = new UserState(storage); var adapter = new TestAdapter(TestAdapter.CreateConversation(MethodBase.GetCurrentMethod().ToString())); adapter .UseStorage(storage) .UseBotState(userState, convoState) .Use(new TranscriptLoggerMiddleware(new TraceTranscriptLogger(traceActivity: false))); return(new TestFlow(adapter, handler)); }
private TestFlow CreateFlow(BotCallbackHandler handler) { var storage = new MemoryStorage(); var convoState = new ConversationState(storage); var userState = new UserState(storage); var adapter = new TestAdapter(TestAdapter.CreateConversation(TestContext.TestName)); adapter .UseStorage(storage) .UseState(userState, convoState) .Use(new TranscriptLoggerMiddleware(new TraceTranscriptLogger(traceActivity: false))); return(new TestFlow(adapter, handler)); }
public async Task <object> ProcessActivity(Payload actionPayload, BotCallbackHandler callback) { TurnContext context = null; try { var activity = RequestToActivity(actionPayload); BotAssert.ActivityNotNull(activity); context = new TurnContext(this, activity); Responses = new Dictionary <string, List <Activity> >(); await base.RunPipelineAsync(context, callback, default(CancellationToken)).ConfigureAwait(false); var key = $"{activity.Conversation.Id}:{activity.Id}"; try { object response = null; var activities = Responses.ContainsKey(key) ? Responses[key] : new List <Activity>(); if (WebhookType == GoogleWebhookType.DialogFlow) { response = CreateDialogFlowResponseFromLastActivity(activities, context); } else { response = CreateConversationResponseFromLastActivity(activities, context); } return(response); } finally { if (Responses.ContainsKey(key)) { Responses.Remove(key); } } } catch (Exception ex) { await OnTurnError(context, ex); throw; } }
private async Task <ResourceResponse> ProcessActivityAsync(ClaimsIdentity claimsIdentity, string conversationId, string replyToActivityId, Activity activity, CancellationToken cancellationToken) { var skillConversationReference = await GetSkillConversationReferenceAsync(conversationId, cancellationToken).ConfigureAwait(false); ResourceResponse resourceResponse = null; var callback = new BotCallbackHandler(async(turnContext, ct) => { turnContext.TurnState.Add(_skillConversationReferenceKey, skillConversationReference); activity.ApplyConversationReference(skillConversationReference.ConversationReference); turnContext.Activity.Id = replyToActivityId; turnContext.Activity.CallerId = $"{CallerIdConstants.BotToBotPrefix}{JwtTokenValidation.GetAppIdFromClaims(claimsIdentity.Claims)}"; switch (activity.Type) { case ActivityTypes.EndOfConversation: await _conversationIdFactory.DeleteConversationReferenceAsync(conversationId, cancellationToken).ConfigureAwait(false); await SendToBotAsync(activity, turnContext, ct).ConfigureAwait(false); break; case ActivityTypes.Event: await SendToBotAsync(activity, turnContext, ct).ConfigureAwait(false); break; case ActivityTypes.Command: case ActivityTypes.CommandResult: if (activity.Name.StartsWith("application/", StringComparison.Ordinal)) { // Send to channel and capture the resource response for the SendActivityCall so we can return it. resourceResponse = await turnContext.SendActivityAsync(activity, cancellationToken).ConfigureAwait(false); } else { await SendToBotAsync(activity, turnContext, ct).ConfigureAwait(false); } break; default: // Capture the resource response for the SendActivityCall so we can return it. resourceResponse = await turnContext.SendActivityAsync(activity, cancellationToken).ConfigureAwait(false); break; } }); await _adapter.ContinueConversationAsync(claimsIdentity, skillConversationReference.ConversationReference, skillConversationReference.OAuthScope, callback, cancellationToken).ConfigureAwait(false); return(resourceResponse ?? new ResourceResponse(Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture))); }
public async Task OAuthPromptRecognizeTokenAsync_WithNullTextMessageActivity_DoesNotThrow() { var convoState = new ConversationState(new MemoryStorage()); var dialogState = convoState.CreateProperty <DialogState>("dialogState"); var adapter = new TestAdapter() .Use(new AutoSaveStateMiddleware(convoState)); var connectionName = "myConnection"; var retryPromptText = "Sorry, invalid input. Please sign in."; // Create new DialogSet. var dialogs = new DialogSet(dialogState); dialogs.Add(new OAuthPrompt("OAuthPrompt", new OAuthPromptSettings() { Text = "Please sign in", ConnectionName = connectionName, Title = "Sign in" })); BotCallbackHandler botCallbackHandler = async(turnContext, cancellationToken) => { var dc = await dialogs.CreateContextAsync(turnContext, cancellationToken); var results = await dc.ContinueDialogAsync(cancellationToken); if (results.Status == DialogTurnStatus.Empty) { await dc.PromptAsync("OAuthPrompt", new PromptOptions() { RetryPrompt = MessageFactory.Text(retryPromptText) }, cancellationToken : cancellationToken); } }; var messageActivityWithNullText = Activity.CreateMessageActivity(); await new TestFlow(adapter, botCallbackHandler) .Send("hello") .AssertReply(activity => { Assert.Single(((Activity)activity).Attachments); Assert.Equal(OAuthCard.ContentType, ((Activity)activity).Attachments[0].ContentType); Assert.Equal(InputHints.AcceptingInput, ((Activity)activity).InputHint); }) .Send(messageActivityWithNullText) .AssertReply(retryPromptText) .StartTestAsync(); }
[InlineData(true, Channels.Msteams, true)] //Override: show link; ChannelRequiresSingInLink() returns true; Result: show link public async Task OAuthPromptSignInLinkSettingsCases(bool?showSignInLinkValue, string channelId, bool shouldHaveSignInLink) { var oAuthPromptSettings = new OAuthPromptSettings(); oAuthPromptSettings.ShowSignInLink = showSignInLinkValue; var convoState = new ConversationState(new MemoryStorage()); var dialogState = convoState.CreateProperty <DialogState>("dialogState"); var adapter = new TestAdapter() .Use(new AutoSaveStateMiddleware(convoState)); // Create new DialogSet var dialogs = new DialogSet(dialogState); dialogs.Add(new OAuthPrompt("OAuthPrompt", oAuthPromptSettings)); BotCallbackHandler botCallbackHandler = async(turnContext, cancellationToken) => { var dc = await dialogs.CreateContextAsync(turnContext, cancellationToken); var results = await dc.ContinueDialogAsync(cancellationToken); if (results.Status == DialogTurnStatus.Empty) { await dc.PromptAsync("OAuthPrompt", new PromptOptions(), cancellationToken : cancellationToken); } }; var initialActivity = new Activity() { ChannelId = channelId, Text = "hello" }; await new TestFlow(adapter, botCallbackHandler) .Send(initialActivity) .AssertReply(activity => { Assert.Single(((Activity)activity).Attachments); Assert.Equal(OAuthCard.ContentType, ((Activity)activity).Attachments[0].ContentType); var oAuthCard = (OAuthCard)((Activity)activity).Attachments[0].Content; var cardAction = oAuthCard.Buttons[0]; Assert.Equal(shouldHaveSignInLink, cardAction.Value != null); }) .StartTestAsync(); }
/// <summary> /// Starts activity processing for the current bot turn. /// </summary> /// <param name="turnContext">The turn's context object.</param> /// <param name="callback">A callback method to run at the end of the pipeline.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects /// or threads to receive notice of cancellation.</param> /// <returns>A task that represents the work queued to execute.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="turnContext"/> is null.</exception> /// <remarks>The adapter calls middleware in the order in which you added it. /// The adapter passes in the context object for the turn and a next delegate, /// and the middleware calls the delegate to pass control to the next middleware /// in the pipeline. Once control reaches the end of the pipeline, the adapter calls /// the <paramref name="callback"/> method. If a middleware component doesn’t call /// the next delegate, the adapter does not call any of the subsequent middleware’s /// <see cref="IMiddleware.OnTurnAsync(ITurnContext, NextDelegate, CancellationToken)"/> /// methods or the callback method, and the pipeline short circuits. /// <para>When the turn is initiated by a user activity (reactive messaging), the /// callback method will be a reference to the bot's /// <see cref="IBot.OnTurnAsync(ITurnContext, CancellationToken)"/> method. When the turn is /// initiated by a call to <see cref="ContinueConversationAsync(string, ConversationReference, BotCallbackHandler, CancellationToken)"/> /// (proactive messaging), the callback method is the callback method that was provided in the call.</para> /// </remarks> protected async Task RunPipelineAsync(ITurnContext turnContext, BotCallbackHandler callback, CancellationToken cancellationToken) { BotAssert.ContextNotNull(turnContext); // Call any registered Middleware Components looking for ReceiveActivityAsync() if (turnContext.Activity != null) { if (turnContext.Activity.Locale != null) { try { Thread.CurrentThread.CurrentCulture = new CultureInfo(turnContext.Activity.Locale); (turnContext as TurnContext).Locale = turnContext.Activity.Locale; } catch (CultureNotFoundException) { // if turnContext.Activity.Locale is invalid, then TurnContext.Locale will set to Thread.CurrentThread.CurrentCulture.Name as default. (turnContext as TurnContext).Locale = Thread.CurrentThread.CurrentCulture.Name; } } try { await MiddlewareSet.ReceiveActivityWithStatusAsync(turnContext, callback, cancellationToken).ConfigureAwait(false); } catch (Exception e) { if (OnTurnError != null) { await OnTurnError.Invoke(turnContext, e).ConfigureAwait(false); } else { throw; } } } else { // call back to caller on proactive case if (callback != null) { await callback(turnContext, cancellationToken).ConfigureAwait(false); } } }
public async Task ContinueConversationAsync(ConversationReference reference, BotCallbackHandler logic, CancellationToken cancellationToken) { if (reference == null) { throw new ArgumentNullException(nameof(reference)); } if (logic == null) { throw new ArgumentNullException(nameof(logic)); } var request = reference.GetContinuationActivity().ApplyConversationReference(reference, true); using (var context = new TurnContext(this, request)) { await RunPipelineAsync(context, logic, cancellationToken).ConfigureAwait(false); } }
public async Task ProcessActivityBySocketAsync( BotCallbackHandler callback = null ) { await InitUserIfNeeded(); var socket = new SlackRtmClient(options.BotUserToken); await socket.Connect().ConfigureAwait(false); var sub = socket.Messages.Subscribe(async(message) => { await ProcessActivityAsync(message, callback); }); await socket.Events; sub.Dispose(); }
private TestFlow CreateNoResourceExplorerFlow(string locale, BotCallbackHandler handler) { TypeFactory.Configuration = new ConfigurationBuilder().Build(); var storage = new MemoryStorage(); var convoState = new ConversationState(storage); var userState = new UserState(storage); var adapter = new TestAdapter(TestAdapter.CreateConversation(TestContext.TestName)); adapter .UseStorage(storage) .UseState(userState, convoState) .UseAdaptiveDialogs() .UseLanguageGeneration() .Use(new TranscriptLoggerMiddleware(new FileTranscriptLogger())); return(new TestFlow(adapter, handler)); }
/// <inheritdoc/> public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback, Inspector inspector = null) { var typing = adapter.MakeActivity(); typing.Type = ActivityTypes.Typing; if (!string.IsNullOrEmpty(User)) { typing.From = ObjectPath.Clone(typing.From); typing.From.Id = User; typing.From.Name = User; } Stopwatch sw = new Stopwatch(); sw.Start(); await adapter.ProcessActivityAsync((Activity)typing, callback, default).ConfigureAwait(false);
internal async Task <ResourceResponse> OnUpdateActivityAsync(ClaimsIdentity claimsIdentity, string conversationId, string activityId, Activity activity, CancellationToken cancellationToken = default) { var skillConversationReference = await GetSkillConversationReferenceAsync(conversationId, cancellationToken).ConfigureAwait(false); ResourceResponse resourceResponse = null; var callback = new BotCallbackHandler(async(turnContext, ct) => { turnContext.TurnState.Add(_skillConversationReferenceKey, skillConversationReference); activity.ApplyConversationReference(skillConversationReference.ConversationReference); turnContext.Activity.Id = activityId; turnContext.Activity.CallerId = $"{CallerIdConstants.BotToBotPrefix}{JwtTokenValidation.GetAppIdFromClaims(claimsIdentity.Claims)}"; resourceResponse = await turnContext.UpdateActivityAsync(activity, cancellationToken).ConfigureAwait(false); }); await _adapter.ContinueConversationAsync(claimsIdentity, skillConversationReference.ConversationReference, skillConversationReference.OAuthScope, callback, cancellationToken).ConfigureAwait(false); return(resourceResponse ?? new ResourceResponse(Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture))); }
public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback) { if (this.Text == null) { throw new Exception("You must define the Text property"); } var activity = adapter.MakeActivity(this.Text); if (!string.IsNullOrEmpty(this.User)) { activity.From = ObjectPath.Clone(activity.From); activity.From.Id = this.User; activity.From.Name = this.User; } await adapter.ProcessActivityAsync(activity, callback, default(CancellationToken)).ConfigureAwait(false); }
public async Task ProcessActivityAsyncForForwardedActivity() { var botAppId = "00000000-0000-0000-0000-000000000001"; var skill1AppId = "00000000-0000-0000-0000-000000skill1"; var claims = new List <Claim> { new Claim(AuthenticationConstants.AudienceClaim, skill1AppId), new Claim(AuthenticationConstants.AppIdClaim, botAppId), new Claim(AuthenticationConstants.VersionClaim, "1.0") }; var identity = new ClaimsIdentity(claims); var credentialProvider = new SimpleCredentialProvider() { AppId = botAppId }; var serviceUrl = "https://root-bot.test.azurewebsites.net/"; var callback = new BotCallbackHandler((context, ct) => { GetAppCredentialsAndAssertValues(context, skill1AppId, botAppId, 1); GetConnectorClientsAndAssertValues( context, skill1AppId, botAppId, new Uri(serviceUrl), 1); var scope = context.TurnState.Get <string>(BotAdapter.OAuthScopeKey); Assert.Equal(botAppId, scope); Assert.Equal($"{CallerIdConstants.BotToBotPrefix}{botAppId}", context.Activity.CallerId); return(Task.CompletedTask); }); var sut = new BotFrameworkAdapter(credentialProvider); await sut.ProcessActivityAsync( identity, new Activity("From root-bot") { ChannelId = Channels.Emulator, ServiceUrl = serviceUrl }, callback, CancellationToken.None); }
/// <inheritdoc/> public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback, Inspector inspector = null) { if (inspector != null) { await inspector((dc) => { foreach (var assignment in Assignments) { dc.State.SetValue(assignment.Property.GetValue(dc.State), assignment.Value.GetValue(dc.State)); } }).ConfigureAwait(false); Trace.TraceInformation($"[Turn Ended => SetProperties completed]"); } else { throw new InvalidOperationException("No inspector to use for setting properties"); } }
/// <summary> /// Sends the personal message using bot context and message activity for a user /// </summary> /// <param name="context">The context.</param> /// <param name="message">The message.</param> /// <param name="cancellationToken">Cancelation token</param> /// <param name="to">Recipient</param> public async Task SendPersonalMessageTo(ITurnContext context, Activity message, CancellationToken cancellationToken, ChannelAccount to) { var teamsChannelId = context.Activity.ChannelId; var botAdapter = (BotFrameworkAdapter)context.Adapter; var serviceUrl = context.Activity.ServiceUrl; var parameters = new ConversationParameters { IsGroup = false, Bot = context.Activity.Recipient, Members = new[] { to }, TenantId = tenantInfo.Id, }; BotCallbackHandler createConversationcallback = async(createConvContext, createConvCancellationToken) => { await createConvContext.SendActivityAsync(message, cancellationToken); }; await botAdapter.CreateConversationAsync(teamsChannelId, serviceUrl, microsoftAppCredentials, parameters, createConversationcallback, cancellationToken); }
public async Task ProcessActivityAsync( MessageEvent message, BotCallbackHandler callback = null ) { await InitUserIfNeeded(); switch (message.Type) { case "message": await OnMessageReceived(message, callback); break; default: // TODO: Implement non-message type break; } }
public async Task ProcessActivityAsyncCreatesCorrectCredsAndClient(string botAppId, string expectedCallerId, string channelService, string expectedScope, int expectedAppCredentialsCount, int expectedClientCredentialsCount) { var claims = new List <Claim>(); if (botAppId != null) { claims.Add(new Claim(AuthenticationConstants.AudienceClaim, botAppId)); claims.Add(new Claim(AuthenticationConstants.AppIdClaim, botAppId)); claims.Add(new Claim(AuthenticationConstants.VersionClaim, "1.0")); } var identity = new ClaimsIdentity(claims); var credentialProvider = new SimpleCredentialProvider { AppId = botAppId }; var serviceUrl = "https://smba.trafficmanager.net/amer/"; var callback = new BotCallbackHandler((context, ct) => { GetAppCredentialsAndAssertValues(context, botAppId, expectedScope, expectedAppCredentialsCount); GetConnectorClientsAndAssertValues( context, botAppId, expectedScope, new Uri(serviceUrl), expectedClientCredentialsCount); var scope = context.TurnState.Get <string>(BotAdapter.OAuthScopeKey); Assert.Equal(expectedCallerId, context.Activity.CallerId); return(Task.CompletedTask); }); var sut = new BotFrameworkAdapter(credentialProvider, new SimpleChannelProvider(channelService)); await sut.ProcessActivityAsync( identity, new Activity("test") { ChannelId = Channels.Emulator, ServiceUrl = serviceUrl }, callback, CancellationToken.None); }
public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback) { var timeout = (int)this.Timeout; if (System.Diagnostics.Debugger.IsAttached) { timeout = int.MaxValue; } CancellationTokenSource cts = new CancellationTokenSource(); cts.CancelAfter((int)timeout); IActivity replyActivity = await adapter.GetNextReplyAsync(cts.Token).ConfigureAwait(false); if (replyActivity != null) { ValidateReply((Activity)replyActivity); return; } }
public async Task ProcessActivity(DirectMessageEvent obj, BotCallbackHandler callback) { TurnContext context = null; try { var activity = RequestToActivity(obj); BotAssert.ActivityNotNull(activity); context = new TurnContext(this, activity); await RunPipelineAsync(context, callback, default).ConfigureAwait(false); } catch (Exception ex) { await OnTurnError(context, ex); throw; } }
public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback) { if (this.Activity == null) { throw new Exception("You must define one of Text or Activity properties"); } var activity = ObjectPath.Clone(this.Activity); activity.ApplyConversationReference(adapter.Conversation, isIncoming: true); if (!string.IsNullOrEmpty(this.User)) { activity.From = ObjectPath.Clone(activity.From); activity.From.Id = this.User; activity.From.Name = this.User; } await adapter.ProcessActivityAsync(this.Activity, callback, default(CancellationToken)).ConfigureAwait(false); }
private TestFlow CreateFlow(BotCallbackHandler handler, string locale = null) { var storage = new MemoryStorage(); var convoState = new ConversationState(storage); var userState = new UserState(storage); var adapter = new TestAdapter(TestAdapter.CreateConversation(MethodBase.GetCurrentMethod().ToString())); adapter .UseStorage(storage) .UseBotState(userState, convoState) .Use(new TranscriptLoggerMiddleware(new TraceTranscriptLogger(traceActivity: false))); if (!string.IsNullOrEmpty(locale)) { adapter.Locale = locale; } return(new TestFlow(adapter, handler)); }
public async Task PollForTokenAsync(PollingParams pollingParams) { BotCallbackHandler continueCallback = async(context, ctoken) => { // TODO: Should be using OAuthClient //var oauthClient = context.TurnState.Get<OAuthClient>(); //var tokenResponse = await oauthClient.UserToken.GetTokenAsync(Activity.From.Id, pollingParams.ConnectionName, Activity.ChannelId, null, ctoken).ConfigureAwait(false); var tokenResponse = await(Adapter as BotFrameworkAdapter).GetUserTokenAsync(context, pollingParams.ConnectionName, null, ctoken).ConfigureAwait(false); if (tokenResponse != null) { // This can be used to short-circuit the polling loop. if (tokenResponse.Properties != null) { tokenResponse.Properties.TryGetValue(TurnStateConstants.TokenPollingSettingsKey, out var tokenPollingSettingsToken); var tokenPollingSettings = tokenPollingSettingsToken?.ToObject <TokenPollingSettings>(); if (tokenPollingSettings != null) { Logger.LogInformation($"PollForTokenAsync received new polling settings: timeout={tokenPollingSettings.Timeout}, interval={tokenPollingSettings.Interval}", tokenPollingSettings); pollingParams.ShouldEndPolling = tokenPollingSettings.Timeout <= 0 ? true : pollingParams.ShouldEndPolling; // Timeout now and stop polling pollingParams.PollingInterval = tokenPollingSettings.Interval > 0 ? TimeSpan.FromMilliseconds(tokenPollingSettings.Interval) : pollingParams.PollingInterval; // Only overrides if it is set. } } // once there is a token, send it to the bot and stop polling if (tokenResponse.Token != null) { var tokenResponseActivityEvent = CreateTokenResponse(Activity.GetConversationReference(), tokenResponse.Token, pollingParams.ConnectionName); await Adapter.ProcessActivityAsync(Identity, tokenResponseActivityEvent, Callback, ctoken).ConfigureAwait(false); pollingParams.ShouldEndPolling = true; pollingParams.SentToken = true; Logger.LogInformation("PollForTokenAsync completed with a token", Activity); } } }; await Adapter.ContinueConversationAsync(Identity, Activity.GetConversationReference(), continueCallback, cancellationToken : CancellationToken).ConfigureAwait(false); }
public async Task ProcessActivityAsyncCreatesCorrectCredsAndClient() { var botAppId = "00000000-0000-0000-0000-000000000001"; var claims = new List <Claim> { new Claim(AuthenticationConstants.AudienceClaim, botAppId), new Claim(AuthenticationConstants.AppIdClaim, botAppId), new Claim(AuthenticationConstants.VersionClaim, "1.0") }; var identity = new ClaimsIdentity(claims); var credentialProvider = new SimpleCredentialProvider() { AppId = botAppId }; var serviceUrl = "https://smba.trafficmanager.net/amer/"; var callback = new BotCallbackHandler(async(context, ct) => { GetCredsAndAssertValues(context, botAppId, AuthenticationConstants.ToChannelFromBotOAuthScope, 1); GetClientAndAssertValues( context, botAppId, AuthenticationConstants.ToChannelFromBotOAuthScope, new Uri(serviceUrl), 1); var scope = context.TurnState.Get <string>(BotAdapter.OAuthScopeKey); Assert.AreEqual(AuthenticationConstants.ToChannelFromBotOAuthScope, scope); }); var sut = new BotFrameworkAdapter(credentialProvider); await sut.ProcessActivityAsync( identity, new Activity("test") { ChannelId = Channels.Emulator, ServiceUrl = serviceUrl }, callback, CancellationToken.None); }
private async Task <ResourceResponse> ProcessActivityAsync(ClaimsIdentity claimsIdentity, string conversationId, string replyToActivityId, Activity activity, CancellationToken cancellationToken) { var conversationReference = await _conversationIdIdFactory.GetConversationReferenceAsync(conversationId, CancellationToken.None).ConfigureAwait(false); if (conversationReference == null) { throw new KeyNotFoundException(); } var skillConversationReference = activity.GetConversationReference(); var callback = new BotCallbackHandler(async(turnContext, ct) => { turnContext.TurnState.Add(SkillConversationReferenceKey, skillConversationReference); activity.ApplyConversationReference(conversationReference); turnContext.Activity.Id = replyToActivityId; switch (activity.Type) { case ActivityTypes.EndOfConversation: await _conversationIdIdFactory.DeleteConversationReferenceAsync(conversationId, cancellationToken).ConfigureAwait(false); ApplyEoCToTurnContextActivity(turnContext, activity); await _bot.OnTurnAsync(turnContext, ct).ConfigureAwait(false); break; case ActivityTypes.Event: ApplyEventToTurnContextActivity(turnContext, activity); await _bot.OnTurnAsync(turnContext, ct).ConfigureAwait(false); break; default: await turnContext.SendActivityAsync(activity, cancellationToken).ConfigureAwait(false); break; } }); await _adapter.ContinueConversationAsync(claimsIdentity, conversationReference, callback, cancellationToken).ConfigureAwait(false); return(new ResourceResponse(Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture))); }
/// <summary> /// Primary adapter method for processing activities sent from calling bot. /// </summary> /// <param name="activity">The activity to process.</param> /// <param name="callback">The BotCallBackHandler to call on completion.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>The response to the activity.</returns> public async Task <InvokeResponse> ProcessActivityAsync(Activity activity, BotCallbackHandler callback, CancellationToken cancellationToken) { BotAssert.ActivityNotNull(activity); _botTelemetryClient.TrackTrace($"Received an incoming activity. ActivityId: {activity.Id}", Severity.Information, null); using (var context = new TurnContext(this, activity)) { await RunPipelineAsync(context, callback, cancellationToken).ConfigureAwait(false); // We do not support Invoke in websocket transport if (activity.Type == ActivityTypes.Invoke) { return(new InvokeResponse { Status = (int)HttpStatusCode.NotImplemented }); } return(null); } }
/// <inheritdoc/> public override async Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback, Inspector inspector = null) { var timeout = (int)Timeout; if (Debugger.IsAttached) { timeout = int.MaxValue; } using (var cts = new CancellationTokenSource()) { cts.CancelAfter((int)timeout); var replyActivity = await adapter.GetNextReplyAsync(cts.Token).ConfigureAwait(false); if (replyActivity != null) { ValidateReply((Activity)replyActivity); return; } } }
/// <inheritdoc/> public async override Task ExecuteAsync(TestAdapter adapter, BotCallbackHandler callback, Inspector inspector = null) { if (Name == null) { throw new InvalidOperationException("You must define the event name."); } var eventActivity = adapter.MakeActivity(); eventActivity.Type = ActivityTypes.Event; eventActivity.Name = Name; eventActivity.Value = Value; Stopwatch sw = new Stopwatch(); sw.Start(); await adapter.ProcessActivityAsync(eventActivity, callback, default).ConfigureAwait(false); sw.Stop(); Trace.TraceInformation($"[Turn Ended => {sw.ElapsedMilliseconds} ms processing CustomEvent: {Name} ]"); }
public async Task OAuthPromptInNotSupportedChannelShouldAddSignInCard() { var convoState = new ConversationState(new MemoryStorage()); var dialogState = convoState.CreateProperty <DialogState>("dialogState"); var adapter = new TestAdapter() .Use(new AutoSaveStateMiddleware(convoState)); // Create new DialogSet var dialogs = new DialogSet(dialogState); dialogs.Add(new OAuthPrompt("OAuthPrompt", new OAuthPromptSettings())); BotCallbackHandler botCallbackHandler = async(turnContext, cancellationToken) => { var dc = await dialogs.CreateContextAsync(turnContext, cancellationToken); var results = await dc.ContinueDialogAsync(cancellationToken); if (results.Status == DialogTurnStatus.Empty) { await dc.PromptAsync("OAuthPrompt", new PromptOptions(), cancellationToken : cancellationToken); } }; var initialActivity = new Activity() { ChannelId = Channels.Skype, Text = "hello" }; await new TestFlow(adapter, botCallbackHandler) .Send(initialActivity) .AssertReply(activity => { Assert.Single(((Activity)activity).Attachments); Assert.Equal(SigninCard.ContentType, ((Activity)activity).Attachments[0].ContentType); }) .StartTestAsync(); }
private async Task TestActivityCallback(Activity activity) { BotCallbackHandler botCallback = null; _mockAdapter.Setup(x => x.ContinueConversationAsync(It.IsAny <ClaimsIdentity>(), It.IsAny <ConversationReference>(), It.IsAny <string>(), It.IsAny <BotCallbackHandler>(), It.IsAny <CancellationToken>())) .Callback <ClaimsIdentity, ConversationReference, string, BotCallbackHandler, CancellationToken>((identity, reference, audience, callback, cancellationToken) => { botCallback = callback; Console.WriteLine("blah"); }); var sut = CreateSkillHandlerForTesting(); var activityId = Guid.NewGuid().ToString("N"); activity.ApplyConversationReference(_conversationReference); await sut.TestOnReplyToActivityAsync(_claimsIdentity, _conversationId, activityId, activity, CancellationToken.None); Assert.IsNotNull(botCallback); await botCallback.Invoke(new TurnContext(_mockAdapter.Object, activity), CancellationToken.None); }