Beispiel #1
0
        public async Task <ActionResult <BotGatewayResponse> > InitAssistantAsync([FromBody] Activity activity, CancellationToken cancellationToken = default(CancellationToken))
        {
            var ti0          = DateTime.Now;
            var conversation = await _directLineClient.Conversations.StartConversationAsync(cancellationToken);

            var elapsed = DateTime.Now.Subtract(ti0).TotalMilliseconds;

            ti0 = DateTime.Now;
            var response = await _directLineClient.Conversations.PostActivityAsync(conversation.ConversationId, activity, cancellationToken);

            elapsed = DateTime.Now.Subtract(ti0).TotalMilliseconds;
            // TODO: Init shouldn't return a response, this seems to be a bug.
            var r = await GetResponses(conversation.ConversationId, null, _directLineClient, cancellationToken);

            var initResponse = new BotGatewayResponse
            {
                Activities = new List <Activity> {
                    GetFakeActivity()
                },
                ConversationId = conversation.ConversationId,
                Watermark      = r.Watermark
            };

            return(new ActionResult <BotGatewayResponse>(Ok(initResponse)));
        }
 private static void RenderResponse(BotGatewayResponse lastResponse, long clientRoundtripTime)
 {
     ConsoleOut.WriteTiming("\tClient roundtrip duration (ms):", clientRoundtripTime);
     Console.WriteLine($"\tActivities received: {lastResponse.Activities.Count}");
     Console.WriteLine($"\tWatermark: {lastResponse.Watermark}");
     ConsoleOut.WriteTiming("\tServer: Reconnect (and post) duration (ms):", lastResponse.Diagnostics.ReconnectAndPostDuration);
     ConsoleOut.WriteTiming("\tServer: Get response duration (ms):", lastResponse.Diagnostics.GetResponseDuration);
     Console.WriteLine($"\tServer: Get response retries: {lastResponse.Diagnostics.GetResponseTries:N0}");
 }
Beispiel #3
0
        private async Task <BotGatewayResponse> GetResponses(string conversationId, string watermark, DirectLineClient directLineClient, CancellationToken cancellationToken)
        {
            // TODO, replace polling by sockets
            //using (var webSocketClient = new WebSocket(_directLineClient.Conversations.StreamUrl))
            //{
            //    webSocketClient.OnMessage += WebSocketClient_OnMessage;

            //    // You have to specify TLS version to 1.2 or connection will be failed in handshake.
            //    webSocketClient.SslConfiguration.EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12;
            //    webSocketClient.Connect();

            //    while (true)
            //    {
            //                await directLineClient.Conversations.PostActivityAsync(conversation.ConversationId, userMessage);
            //    }

            //}

            // wait and send back as soon as we get at least one answer
            try
            {
                var             tryCount = 0;
                List <Activity> activities;
                var             stopwatch = Stopwatch.StartNew();
                while (true)
                {
                    tryCount++;
                    var activitySet = await directLineClient.Conversations.GetActivitiesAsync(conversationId, watermark, cancellationToken);

                    if (activitySet != null)
                    {
                        watermark = activitySet.Watermark;

                        if (activitySet.Activities.Count > 0)
                        {
                            var receivedActivities = activitySet.Activities.Where(a => a.From.Id == _botId).ToList();

                            if (receivedActivities.Any())
                            {
                                activities = receivedActivities;
                                break;
                            }
                        }
                    }

                    await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
                }

                stopwatch.Stop();

                var responses = new BotGatewayResponse
                {
                    Activities     = activities,
                    ConversationId = conversationId,
                    Watermark      = watermark,
                    Diagnostics    = new DiagnosticsData
                    {
                        GetResponseDuration = stopwatch.ElapsedMilliseconds,
                        GetResponseTries    = tryCount
                    }
                };

                return(responses);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                throw;
            }
        }