public static StreamingRequest GetStreamingRequestWithoutAttachments(string conversationId)
{
var conId = string.IsNullOrWhiteSpace(conversationId) ? Guid.NewGuid().ToString() : conversationId;
var request = new StreamingRequest()
{
Verb = "POST",
Path = $"/v3/directline/conversations/{conId}/activities",
};
var activity = new Schema.Activity()
{
Type = "message",
Text = "hello",
ServiceUrl = "urn:test:namedpipe:testPipes",
From = new Schema.ChannelAccount()
{
Id = "123",
Name = "Fred",
},
Conversation = new Schema.ConversationAccount(null, null, conId, null, null, null, null),
};
request.SetBody(activity);
return(request);
}
public static StreamingRequest GetStreamingRequestWithAttachment(string conversationId)
{
var conId = string.IsNullOrWhiteSpace(conversationId) ? Guid.NewGuid().ToString() : conversationId;
var attachmentData = "blah blah i am a stream!";
var streamContent = new MemoryStream(Encoding.UTF8.GetBytes(attachmentData));
var attachmentStream = new AttachmentStream("botframework-stream", streamContent);
var request = new StreamingRequest()
{
Verb = "POST",
Path = $"/v3/directline/conversations/{conId}/activities",
};
var activity = new Schema.Activity()
{
Type = "message",
Text = "hello",
ServiceUrl = "urn:test:namedpipe:testPipes",
From = new Schema.ChannelAccount()
{
Id = "123",
Name = "Fred",
},
Conversation = new Schema.ConversationAccount(null, null, conId, null, null, null, null),
};
request.SetBody(activity);
var contentStream = new StreamContent(attachmentStream.ContentStream);
contentStream.Headers.TryAddWithoutValidation(HeaderNames.ContentType, attachmentStream.ContentType);
request.AddStream(contentStream);
return(request);
}
public async Task ItGetsUserAgentInfo()
{
// Arrange
// Act
var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), "fakePipe");
var activity = new Schema.Activity()
{
Type = "message",
Text = "received from bot",
From = new Schema.ChannelAccount()
{
Id = "bot",
Name = "bot",
},
Conversation = new Schema.ConversationAccount(null, null, "testconvoid", null, null, null, null),
};
var payload = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(activity, SerializationSettings.DefaultDeserializationSettings)));
var fakeContentStreamId = Guid.NewGuid();
var fakeContentStream = new FakeContentStream(fakeContentStreamId, "application/json", payload);
var testRequest = new ReceiveRequest();
testRequest.Path = "/api/version";
testRequest.Verb = "GET";
testRequest.Streams.Add(fakeContentStream);
var response = await handler.ProcessRequestAsync(testRequest);
// Assert
Assert.NotNull(response);
}
public async void ItGetsUserAgentInfo()
{
// Arrange
var expectation = new Regex("{\"userAgent\":\"Microsoft-BotFramework\\/[0-9.]+\\s.*BotBuilder\\/[0-9.]+\\s+\\(.*\\)\".*}");
// Act
var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), Guid.NewGuid().ToString());
var activity = new Schema.Activity()
{
Type = "message",
Text = "received from bot",
From = new Schema.ChannelAccount()
{
Id = "bot",
Name = "bot",
},
Conversation = new Schema.ConversationAccount(null, null, Guid.NewGuid().ToString(), null, null, null, null),
};
var payload = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(activity, SerializationSettings.DefaultDeserializationSettings)));
var fakeContentStreamId = Guid.NewGuid();
var fakeContentStream = new FakeContentStream(fakeContentStreamId, "application/json", payload);
var testRequest = new ReceiveRequest();
testRequest.Path = "/api/version";
testRequest.Verb = "GET";
testRequest.Streams.Add(fakeContentStream);
var response = await handler.ProcessRequestAsync(testRequest);
// Assert
Assert.Matches(expectation, response.Streams[0].Content.ReadAsStringAsync().Result);
}
public void ShouldReturnEmptyFromContextActivityMissingChannel()
{
var testActivity = new Schema.Activity()
{
ChannelId = null
};
var testContext = new TurnContext(new BotFrameworkAdapter(new SimpleCredentialProvider()), testActivity);
var channelId = Channel.GetChannelId(testContext);
Assert.AreEqual(channelId, string.Empty);
}
public void ShouldReturnChannelIdFromContextActivity()
{
var testActivity = new Schema.Activity()
{
ChannelId = Channels.Facebook
};
var testContext = new TurnContext(new BotFrameworkAdapter(new SimpleCredentialProvider()), testActivity);
var channelId = Channel.GetChannelId(testContext);
Assert.AreEqual(Channels.Facebook, channelId);
}
public static Func <Schema.Activity, Task <InvokeResponse> > ProcessActivityWithAttachments(MockBot mockBot, Conversation conversation)
{
var attachmentStreamData = new List <string>();
Func <Schema.Activity, Task <InvokeResponse> > processActivity = async(activity) =>
{
if (activity.Attachments != null)
{
foreach (Schema.Attachment attachment in activity.Attachments)
{
if (attachment.ContentType.Contains("botframework-stream"))
{
var stream = attachment.Content as Stream;
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
attachmentStreamData.Add(reader.ReadToEnd());
}
var testActivity = new Schema.Activity()
{
Type = "message",
Text = "received from bot",
From = new Schema.ChannelAccount()
{
Id = "bot",
Name = "bot",
},
Conversation = new Schema.ConversationAccount(null, conversation.ConversationId, null),
};
var attachmentData1 = "blah blah i am a stream!";
var streamContent1 = new MemoryStream(Encoding.UTF8.GetBytes(attachmentData1));
var attachmentData2 = "blah blah i am also a stream!";
var streamContent2 = new MemoryStream(Encoding.UTF8.GetBytes(attachmentData2));
await mockBot.SendActivityAsync(testActivity, new List <AttachmentStream>()
{
new AttachmentStream("bot-stream1", streamContent1),
});
await mockBot.SendActivityAsync(testActivity, new List <AttachmentStream>()
{
new AttachmentStream("bot-stream2", streamContent2),
});
}
}
}
return(null);
};
return(processActivity);
}
private static async Task MessageAsync()
{
if (_client == null || !_client.IsConnected)
{
WriteLine("[Program] Client is not connected, connect before sending messages.");
}
var text = AskUser("[Program] Enter text:");
WriteLine($"[User]: {text}", ConsoleColor.Cyan);
if (string.IsNullOrEmpty(_conversationId))
{
_conversationId = Guid.NewGuid().ToString();
}
var activity = new Schema.Activity()
{
Id = Guid.NewGuid().ToString(),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = _conversationId
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "Test",
Text = text,
};
var request = StreamingRequest.CreatePost("/api/messages", new StringContent(JsonConvert.SerializeObject(activity), Encoding.UTF8, "application/json"));
var stopwatch = Stopwatch.StartNew();
var response = await _client.SendAsync(request, CancellationToken.None);
}
public async Task <Schema.ResourceResponse> SendActivityAsync(Schema.Activity activity, List <AttachmentStream> attachmentStreams = null)
{
SentActivities.Add(activity);
var requestPath = $"/v3/conversations/{activity.Conversation?.Id}/activities/{activity.Id}";
var request = StreamingRequest.CreatePost(requestPath);
request.SetBody(activity);
attachmentStreams?.ForEach(a =>
{
var streamContent = new StreamContent(a.ContentStream);
streamContent.Headers.TryAddWithoutValidation(HeaderNames.ContentType, a.ContentType);
request.AddStream(streamContent);
});
var serverResponse = await _adapter.ProcessStreamingActivityAsync(activity, OnTurnAsync, CancellationToken.None).ConfigureAwait(false);
if (serverResponse.Status == (int)HttpStatusCode.OK)
{
return(JsonConvert.DeserializeObject <Schema.ResourceResponse>(serverResponse.Body.ToString()));
}
throw new Exception("SendActivityAsync failed");
}
/// <summary>
/// Return recognition results.
/// </summary>
/// <param name="dc">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="activity">The incoming activity received from the user. The Text property value is used as the query text for QnA Maker.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <param name="telemetryProperties">Additional properties to be logged to telemetry with the LuisResult event.</param>
/// <param name="telemetryMetrics">Additional metrics to be logged to telemetry with the LuisResult event.</param>
/// <returns>A <see cref="RecognizerResult"/> containing the QnA Maker result.</returns>
public override async Task <RecognizerResult> RecognizeAsync(DialogContext dc, Schema.Activity activity, CancellationToken cancellationToken, Dictionary <string, string> telemetryProperties = null, Dictionary <string, double> telemetryMetrics = null)
{
var text = activity.Text ?? string.Empty;
var detectAmbiguity = DetectAmbiguousIntents.GetValue(dc.State);
_modelFolder = ModelFolder.GetValue(dc.State);
_snapshotFile = SnapshotFile.GetValue(dc.State);
InitializeModel();
var recognizerResult = new RecognizerResult()
{
Text = text,
Intents = new Dictionary <string, IntentScore>(),
};
if (string.IsNullOrWhiteSpace(text))
{
// nothing to recognize, return empty recognizerResult
return(recognizerResult);
}
if (ExternalEntityRecognizer != null)
{
// Run external recognition
var externalResults = await ExternalEntityRecognizer.RecognizeAsync(dc, activity, cancellationToken, telemetryProperties, telemetryMetrics).ConfigureAwait(false);
recognizerResult.Entities = externalResults.Entities;
}
// Score with orchestrator
var results = _resolver.Score(text);
// Add full recognition result as a 'result' property
recognizerResult.Properties.Add(ResultProperty, results);
if (results.Any())
{
var topScore = results[0].Score;
// if top scoring intent is less than threshold, return None
if (topScore < UnknownIntentFilterScore)
{
recognizerResult.Intents.Add(NoneIntent, new IntentScore()
{
Score = 1.0
});
}
else
{
// add top score
recognizerResult.Intents.Add(results[0].Label.Name, new IntentScore()
{
Score = results[0].Score
});
// Disambiguate if configured
if (detectAmbiguity)
{
var thresholdScore = DisambiguationScoreThreshold.GetValue(dc.State);
var classifyingScore = Math.Round(topScore, 2) - Math.Round(thresholdScore, 2);
var ambiguousResults = results.Where(item => item.Score >= classifyingScore).ToList();
if (ambiguousResults.Count > 1)
{
// create a RecognizerResult for each ambiguous result.
var recognizerResults = ambiguousResults.Select(result => new RecognizerResult()
{
Text = text,
AlteredText = result.ClosestText,
Entities = recognizerResult.Entities,
Properties = recognizerResult.Properties,
Intents = new Dictionary <string, IntentScore>()
{
{ result.Label.Name, new IntentScore()
{
Score = result.Score
} }
},
});
// replace RecognizerResult with ChooseIntent => Ambiguous recognizerResults as candidates.
recognizerResult = CreateChooseIntentResult(recognizerResults.ToDictionary(result => Guid.NewGuid().ToString(), result => result));
}
}
}
}
else
{
// Return 'None' if no intent matched.
recognizerResult.Intents.Add(NoneIntent, new IntentScore()
{
Score = 1.0
});
}
await dc.Context.TraceActivityAsync($"{nameof(OrchestratorAdaptiveRecognizer)}Result", JObject.FromObject(recognizerResult), nameof(OrchestratorAdaptiveRecognizer), "Orchestrator Recognition", cancellationToken).ConfigureAwait(false);
TrackRecognizerResult(dc, $"{nameof(OrchestratorAdaptiveRecognizer)}Result", FillRecognizerResultTelemetryProperties(recognizerResult, telemetryProperties, dc), telemetryMetrics);
return(recognizerResult);
}
private async Task RecognizeEntitiesAsync(DialogContext dialogContext, Schema.Activity activity, RecognizerResult recognizerResult)
{
var text = activity.Text ?? string.Empty;
var entityPool = new List <Entity>();
if (EntityRecognizers != null)
{
// add entities from regexrecgonizer to the entities pool
var textEntity = new TextEntity(text);
textEntity.Properties["start"] = 0;
textEntity.Properties["end"] = text.Length;
textEntity.Properties["score"] = 1.0;
entityPool.Add(textEntity);
// process entities using EntityRecognizerSet
var entitySet = new EntityRecognizerSet(EntityRecognizers);
var newEntities = await entitySet.RecognizeEntitiesAsync(dialogContext, activity, entityPool).ConfigureAwait(false);
if (newEntities.Any())
{
entityPool.AddRange(newEntities);
}
entityPool.Remove(textEntity);
}
// map entityPool of Entity objects => RecognizerResult entity format
recognizerResult.Entities = new JObject();
foreach (var entityResult in entityPool)
{
// add value
JToken values;
if (!recognizerResult.Entities.TryGetValue(entityResult.Type, StringComparison.OrdinalIgnoreCase, out values))
{
values = new JArray();
recognizerResult.Entities[entityResult.Type] = values;
}
// The Entity type names are not consistent, map everything to camelcase so we can process them cleaner.
var entity = JObject.FromObject(entityResult);
((JArray)values).Add(entity.GetValue("text", StringComparison.InvariantCulture));
// get/create $instance
if (!recognizerResult.Entities.TryGetValue("$instance", StringComparison.OrdinalIgnoreCase, out JToken instanceRoot))
{
instanceRoot = new JObject();
recognizerResult.Entities["$instance"] = instanceRoot;
}
// add instanceData
if (!((JObject)instanceRoot).TryGetValue(entityResult.Type, StringComparison.OrdinalIgnoreCase, out JToken instanceData))
{
instanceData = new JArray();
instanceRoot[entityResult.Type] = instanceData;
}
var instance = new JObject();
instance.Add("startIndex", entity.GetValue("start", StringComparison.InvariantCulture));
instance.Add("endIndex", entity.GetValue("end", StringComparison.InvariantCulture));
instance.Add("score", (double)1.0);
instance.Add("text", entity.GetValue("text", StringComparison.InvariantCulture));
instance.Add("type", entity.GetValue("type", StringComparison.InvariantCulture));
instance.Add("resolution", entity.GetValue("resolution", StringComparison.InvariantCulture));
((JArray)instanceData).Add(instance);
}
}
public Task <InvokeResponse> ProcessActivityAsync(Schema.Activity activity)
{
ReceivedActivities.Add(activity);
return(_processActivityAsync(activity));
}
