public override Task <RecognizerResult> RecognizeAsync(DialogContext dialogContext, Activity activity, CancellationToken cancellationToken = default, Dictionary <string, string> telemetryProperties = null, Dictionary <string, double> telemetryMetrics = null)
{
if (dialogContext == null)
{
throw new ArgumentNullException(nameof(dialogContext));
}
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
var recognized = new RecognizerResult {
Text = activity.Text
};
if (activity.Type == ActivityTypes.Message)
{
// Check for submission of an adaptive card
if (string.IsNullOrEmpty(activity.Text) && activity.Value != null)
{
var value = JObject.FromObject(activity.Value);
// Map submitted values to a recognizer result, value : { "foo": 13} => Entities { "foo": [ 13 ] }
foreach (var property in value.Properties())
{
if (property.Name.ToLower() == "intent")
{
recognized.Intents[property.Value.ToString()] = new IntentScore {
Score = 1.0
};
}
else
{
if (recognized.Entities.Property(property.Name) == null)
{
recognized.Entities[property.Name] = new JArray(property.Value);
}
else
{
((JArray)recognized.Entities[property.Name]).Add(property.Value);
}
}
}
}
}
this.TrackRecognizerResult(dialogContext, "ValueRecognizerResult", this.FillRecognizerResultTelemetryProperties(recognized, telemetryProperties), telemetryMetrics);
return(Task.FromResult(recognized));
}
private async Task ProcessLuisIntent(ITurnContext turnContext, RecognizerResult result, string response)
{
// Match top LUIS intent to appropriate action
switch (result.GetTopScoringIntent().intent)
{
// AMTS: Intent to give patient an address to remember later on - extracts address entity from sentence and stores for later retrieval
case "AMTSRememberAddress":
{
if (result.Entities.Count > 1)
{
response += "\"text\":\"Okay Doctor, " + result.Entities.GetValue("AMTSAddress")[0] + ", I'll remember it.\", \"type\":\"AMTSRememberAddress\"}";
// Save the address into state and recall later
_userHistoryState.patientAMTSAddress = result.Entities.GetValue("AMTSAddress")[0].ToString();
await _userStateAccessor.SetAsync(turnContext, _userHistoryState);
}
else
{
response += "\"text\":\"Sure Doctor, what's the address?\", \"type\":\"AMTSRememberAddress\"}";
// Prompt user for address
}
await turnContext.SendActivityAsync(response);
break;
}
// AMTS: Intent to recall an address that was specified earlier by the user
case "AMTSRecallAddress":
{
if (_userHistoryState.patientAMTSAddress != null)
{
response += "\"text\":\"I think it was " + _userHistoryState.patientAMTSAddress + ".\", \"type\":\"AMTSRecallAddress\"}";
}
else
{
response += "\"text\":\"I don't think you told me an address Doctor.\", \"type\":\"AMTSRememberAddress\"}";
}
await turnContext.SendActivityAsync(response);
break;
}
// If intent isn't matched for some reason, dispatch to QnAMaker
default:
{
await ProcessQnAMakerResponse(turnContext, response);
break;
}
}
}
private void TryScoreEntities(string text, RecognizerResult recognizerResult)
{
if (!this.ScoreEntities)
{
return;
}
var results = _resolver.Score(text, LabelType.Entity);
recognizerResult.Properties.Add(EntitiesProperty, results);
if (results.Any())
{
if (recognizerResult.Entities == null)
{
recognizerResult.Entities = new JObject();
}
var entitiesResult = recognizerResult.Entities;
foreach (var result in results)
{
// add value
JToken values;
if (!entitiesResult.TryGetValue(result.Label.Name, StringComparison.OrdinalIgnoreCase, out values))
{
values = new JArray();
entitiesResult[result.Label.Name] = values;
}
((JArray)values).Add(EntityResultToJObject(text, result));
// get/create $instance
JToken instanceRoot;
if (!recognizerResult.Entities.TryGetValue("$instance", StringComparison.OrdinalIgnoreCase, out instanceRoot))
{
instanceRoot = new JObject();
recognizerResult.Entities["$instance"] = instanceRoot;
}
// add instanceData
JToken instanceData;
if (!((JObject)instanceRoot).TryGetValue(result.Label.Name, StringComparison.OrdinalIgnoreCase, out instanceData))
{
instanceData = new JArray();
instanceRoot[result.Label.Name] = instanceData;
}
((JArray)instanceData).Add(EntityResultToInstanceJObject(text, result));
}
}
}
private async Task IntentVerCentroContacto(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
string phoneDetail = $"Nuestro número de atención son los siguientes:{ Environment.NewLine}" + $"📞+51 945874430{ Environment.NewLine}+📞+51 945874431";
string addressDetail = $"🏥Estamos ubicados en{ Environment.NewLine} Calle lima 345 Ica,Ica";
await stepContext.Context.SendActivityAsync(phoneDetail, cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync(addressDetail, cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync("¿En que mas te puedo ayudar?", cancellationToken : cancellationToken);
}
public static DateTime?GetDateTime(this RecognizerResult recognizerResult)
{
var luisResponse = new SessionizeLuisModel();
luisResponse.Convert(recognizerResult);
DateTime dateTime;
if (TryFindDateTime(luisResponse, out dateTime))
{
return(dateTime);
}
return(null);
}
private ClassifierResult ToResult(RecognizerResult result, bool cleanup)
{
string text = result.Text;
Dictionary <string, double> intents = new Dictionary <string, double>();
foreach (var intent in result.Intents)
{
intents.Add(intent.Key, intent.Value.Score ?? double.NaN);
}
Dictionary <string, List <IEntity> > entities = ToEntities(result, cleanup);
return(new ClassifierResult(text, intents, entities));
}
/// <summary>
/// Fills the event properties for LuisResult event for telemetry.
/// These properties are logged when the recognizer is called.
/// </summary>
/// <param name="recognizerResult">Last activity sent from user.</param>
/// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="telemetryProperties">Additional properties to be logged to telemetry with the LuisResult event.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// additionalProperties
/// <returns>A dictionary that is sent as "Properties" to IBotTelemetryClient.TrackEvent method for the BotMessageSend event.</returns>
protected Task <Dictionary <string, string> > FillLuisEventPropertiesAsync(RecognizerResult recognizerResult, ITurnContext turnContext, Dictionary <string, string> telemetryProperties = null, CancellationToken cancellationToken = default(CancellationToken))
{
var topLuisIntent = recognizerResult.GetTopScoringIntent();
var intentScore = topLuisIntent.score.ToString("N2");
var topTwoIntents = (recognizerResult.Intents.Count > 0) ? recognizerResult.Intents.OrderByDescending(x => x.Value.Score).Take(2).ToArray() : null;
// Add the intent score and conversation id properties
var properties = new Dictionary <string, string>()
{
{ LuisTelemetryConstants.ApplicationIdProperty, _application.ApplicationId },
{ LuisTelemetryConstants.IntentProperty, topTwoIntents?[0].Key ?? string.Empty },
{ LuisTelemetryConstants.IntentScoreProperty, topTwoIntents?[0].Value.Score?.ToString("N2") ?? "0.00" },
{ LuisTelemetryConstants.Intent2Property, (topTwoIntents?.Count() > 1) ? topTwoIntents?[1].Key ?? string.Empty : string.Empty },
{ LuisTelemetryConstants.IntentScore2Property, (topTwoIntents?.Count() > 1) ? topTwoIntents?[1].Value.Score?.ToString("N2") ?? "0.00" : "0.00" },
{ LuisTelemetryConstants.FromIdProperty, turnContext.Activity.From.Id },
};
if (recognizerResult.Properties.TryGetValue("sentiment", out var sentiment) && sentiment is JObject)
{
if (((JObject)sentiment).TryGetValue("label", out var label))
{
properties.Add(LuisTelemetryConstants.SentimentLabelProperty, label.Value <string>());
}
if (((JObject)sentiment).TryGetValue("score", out var score))
{
properties.Add(LuisTelemetryConstants.SentimentScoreProperty, score.Value <string>());
}
}
var entities = recognizerResult.Entities?.ToString();
properties.Add(LuisTelemetryConstants.EntitiesProperty, entities);
// Use the LogPersonalInformation flag to toggle logging PII data, text is a common example
if (LogPersonalInformation && !string.IsNullOrEmpty(turnContext.Activity.Text))
{
properties.Add(LuisTelemetryConstants.QuestionProperty, turnContext.Activity.Text);
}
// Additional Properties can override "stock" properties.
if (telemetryProperties != null)
{
return(Task.FromResult(telemetryProperties.Concat(properties)
.GroupBy(kv => kv.Key)
.ToDictionary(g => g.Key, g => g.First().Value)));
}
return(Task.FromResult(properties));
}
private static void ValidateColorIntent(RecognizerResult result)
{
Assert.AreEqual(1, result.Intents.Count, "Should recognize one intent");
Assert.AreEqual("colorIntent", result.Intents.Select(i => i.Key).First(), "Should recognize colorIntent");
// entity assertions from capture group
dynamic entities = result.Entities;
Assert.IsNotNull(entities.color, "should find color");
Assert.IsNull(entities.code, "should not find code");
Assert.AreEqual(2, entities.color.Count, "should find 2 colors");
Assert.AreEqual("red", (string)entities.color[0], "should find red");
Assert.AreEqual("orange", (string)entities.color[1], "should find orange");
}
public void TrackIntent(IActivity activity, RecognizerResult result)
{
BotAssert.ActivityNotNull(activity);
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var activityAdapter = new ActivityAdapter(activity);
var recognizerResultAdapter = new RecognizerResultAdapter(result);
activityAdapter.TrackIntent(recognizerResultAdapter.IntentResult, this.telemetryClient, this.settings);
}
/// <summary>
/// Validates the colorIntent utterance "I would like colors red and orange".
/// </summary>
/// <param name="result">The <see cref="RecognizerResult"/>.</param>
internal static void ValidateColorIntent(RecognizerResult result)
{
Assert.Single(result.Intents);
Assert.Equal("colorIntent", result.Intents.Select(i => i.Key).First());
// entity assertions from capture group
dynamic entities = result.Entities;
Assert.NotNull(entities.color);
Assert.Null(entities.code);
Assert.Equal(2, entities.color.Count);
Assert.Equal("red", (string)entities.color[0]);
Assert.Equal("orange", (string)entities.color[1]);
}
private async Task IntentVerContato(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
string phoneDetail = $"Nossos números são os seguintes:{Environment.NewLine}" + $" 📞 + 11 99999999{Environment.NewLine} 📞 + 11 88888888";
string addressDetail = $"🏨 Nosso endereço{Environment.NewLine} Rua dos Bobos, 0, Limoeiro";
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync(phoneDetail, cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync(addressDetail, cancellationToken : cancellationToken);
await stepContext.Context.SendActivityAsync("Em que mais posso ajudar?", cancellationToken : cancellationToken);
}
private async Task IntentVerCentroContacto(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
string phoneDetail = $"Los numeros de atención son los siguientes:{Environment.NewLine}" +
$"📞 +593 (06) 2721983{ Environment.NewLine} 📞 +593 (06) 2721595";
string addresDetail = $"🏫 Estamos ubicados en {Environment.NewLine} Espejo y subida a Santa Cruz";
await stepContext.Context.SendActivityAsync(phoneDetail, cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync(addresDetail, cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync("En qué más te puedo ayudar?", cancellationToken : cancellationToken);
}
private static void ValidateCodeIntent(RecognizerResult result)
{
// intent assertions
Assert.Single(result.Intents);
Assert.Equal("codeIntent", result.Intents.Select(i => i.Key).First());
// entity assertions from capture group
dynamic entities = result.Entities;
Assert.NotNull(entities.code);
Assert.Null(entities.color);
Assert.Equal(2, entities.code.Count);
Assert.Equal("a1", (string)entities.code[0]);
Assert.Equal("b2", (string)entities.code[1]);
}
// Based upon https://pauliom.com/2018/11/06/extracting-an-entity-from-luis-in-bot-framework/
public static int GetNumberEntityAsInt(RecognizerResult luisResult, string entityKey, string valuePropertyName = "text")
{
int number = -1;
if (luisResult != null)
{
var data = luisResult.Entities as IDictionary <string, JToken>;
if (data.TryGetValue("number", out JToken value))
{
int.TryParse(value.First.ToString(), out number);
}
}
return(number);
}
/// <summary>
/// Helper function to update greeting state with entities returned by LUIS.
/// </summary>
/// <param name="luisResult">LUIS recognizer <see cref="RecognizerResult"/>.</param>
/// <param name="turnContext">A <see cref="ITurnContext"/> containing all the data needed
/// for processing this conversation turn.</param>
/// <returns>A task that represents the work queued to execute.</returns>
private async Task UpdateGreetingState(RecognizerResult luisResult, ITurnContext turnContext)
{
if (luisResult.Entities != null && luisResult.Entities.HasValues)
{
// Get latest GreetingState
var greetingState = await _greetingStateAccessor.GetAsync(turnContext, () => new GreetingState());
var entities = luisResult.Entities;
// Supported LUIS Entities
string[] userNameEntities = { "userName", "userName_patternAny" };
string[] userLocationEntities = { "userLocation", "userLocation_patternAny" };
// Update any entities
// Note: Consider a confirm dialog, instead of just updating.
foreach (var name in userNameEntities)
{
// Check if we found valid slot values in entities returned from LUIS.
if (entities[name] != null)
{
// Capitalize and set new user name.
var newName = (string)entities[name][0];
greetingState.Name = char.ToUpper(newName[0]) + newName.Substring(1);
break;
}
}
foreach (var city in userLocationEntities)
{
if (entities[city] != null)
{
// Capitalize and set new city.
var newCity = (string)entities[city][0];
if (newCity.Contains("ano"))
{
newCity = "the best city in the world, Milan";
}
greetingState.City = char.ToUpper(newCity[0]) + newCity.Substring(1);
break;
}
}
// Set the new values into state.
await _greetingStateAccessor.SetAsync(turnContext, greetingState);
}
}
private async Task IntentLogin(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
if (Globales.OnSesion)
{
await buttonsInicio(stepContext, cancellationToken, $"Su sesión ya fue iniciada como {Globales.no_contribuyente}");
}
else
{
AdaptiveCardList adaptiveCard = new AdaptiveCardList();
var nameCard = adaptiveCard.CreateAttachment(2, "");
await stepContext.Context.SendActivityAsync(MessageFactory.Attachment(nameCard), cancellationToken);
await Task.Delay(500);
}
await buttonsInicio(stepContext, cancellationToken, "");
}
private async Task IntentVideo(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
await stepContext.Context.SendActivityAsync($"**Para utilizar el aulavirtual desde el móvil 📳:**", cancellationToken : cancellationToken);
await Task.Delay(1000);
await stepContext.Context.SendActivityAsync($"**Por favor mire el siguiente video 😊**", cancellationToken : cancellationToken);
await Task.Delay(2000);
await VideoMoodle.ToShow(stepContext, cancellationToken);
await Task.Delay(5000);
await RespuestaBot.ToShow(stepContext, cancellationToken);
}
private async Task <IEnumerable <Speaker> > GetSpeakers(WaterfallStepContext stepContext)
{
RecognizerResult luisResult = stepContext.Context.TurnState.Get <RecognizerResult>("LuisRecognizerResult");
string name = luisResult.GetSpeakerName();
DateTime?time = luisResult.GetDateTime();
string track = luisResult.GetTrack();
IEnumerable <Speaker> speakers = await _sessionizeService.WhoIsSHeAsync(
stepContext.Context.Activity.Text,
name : name,
time,
track : track); //TODO QUITAR AUMENTAR TIEMPO
return(speakers);
}
/// <summary>
/// When implemented in a bot, handles an incoming activity.
/// </summary>
/// <param name="turnContext">The context object for this turn.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A task that represents the work queued to execute.
/// </returns>
/// <remarks>
/// The <paramref name="turnContext" /> provides information about the
/// incoming activity, and other data needed to process the activity.
/// </remarks>
/// <seealso cref="T:Microsoft.Bot.Builder.ITurnContext" />
/// <seealso cref="T:Microsoft.Bot.Schema.IActivity" />
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
RecognizerResult recognizerResult = await this.recognizer.RecognizeAsync(turnContext, CancellationToken.None).ConfigureAwait(false);
if (recognizerResult.Intents == null || recognizerResult.Intents["RemindMe"] == null)
{
await turnContext.SendActivityAsync("Sorry, I did not get that").ConfigureAwait(false);
}
else
{
TimeEntity timeEntity = recognizerResult.Entities["Time"].ToObject <TimeEntity>();
string remindAbout = recognizerResult.Entities["Reminder"].ToString();
this.proactiveMessageManager.QueueWorkItem(turnContext, "Reminding you about " + remindAbout, TimeSpan.FromSeconds(timeEntity.TimeInSeconds));
}
}
public static async Task <RecognizerResult> ExecuteLuisQuery(IConfiguration configuration, ILogger logger, ITurnContext turnContext, CancellationToken cancellationToken)
{
var bookingDetails = new BookingDetails();
var recognizerResult = new RecognizerResult();
try
{
// Create the LUIS settings from configuration.
var luisApplication = new LuisApplication(
configuration["LuisAppId"],
configuration["LuisAPIKey"],
"https://" + configuration["LuisAPIHostName"]
);
var recognizer = new LuisRecognizer(luisApplication);
// The actual call to LUIS
recognizerResult = await recognizer.RecognizeAsync(turnContext, cancellationToken);
/*var (intent, score) = recognizerResult.GetTopScoringIntent();
* if (intent == "Book_flight")
* {
* // We need to get the result from the LUIS JSON which at every level returns an array.
* bookingDetails.Destination = recognizerResult.Entities["To"]?.FirstOrDefault()?["Airport"]?.FirstOrDefault()?.FirstOrDefault()?.ToString();
* bookingDetails.Origin = recognizerResult.Entities["From"]?.FirstOrDefault()?["Airport"]?.FirstOrDefault()?.FirstOrDefault()?.ToString();
*
* // This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part.
* // TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year.
* bookingDetails.TravelDate = recognizerResult.Entities["datetime"]?.FirstOrDefault()?["timex"]?.FirstOrDefault()?.ToString().Split('T')[0];
* }
* else if (intent == "Open_MS_Facilities_Ticket") {
* // We need to get the result from the LUIS JSON which at every level returns an array.
* bookingDetails.Destination = recognizerResult.Entities["To"]?.FirstOrDefault()?["Airport"]?.FirstOrDefault()?.FirstOrDefault()?.ToString();
* bookingDetails.Origin = recognizerResult.Entities["From"]?.FirstOrDefault()?["Airport"]?.FirstOrDefault()?.FirstOrDefault()?.ToString();
*
* // This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part.
* // TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year.
* bookingDetails.TravelDate = recognizerResult.Entities["datetime"]?.FirstOrDefault()?["timex"]?.FirstOrDefault()?.ToString().Split('T')[0];
* }*/
}
catch (Exception e)
{
logger.LogWarning($"LUIS Exception: {e.Message} Check your LUIS configuration.");
}
return(recognizerResult);
}
public async Task <DialogTurnResult> PerformIntent(string Intent, RecognizerResult result, DialogContext context)
{
switch (Intent)
{
case "CheckInventory":
await SendInterest(context, Constants.INTEREST_Inventory);
break;
case "FindVehicle":
await SendInterest(context, Constants.INTEREST_Inventory);
break;
case "GetFinanced":
await SendInterest(context, Constants.INTEREST_Financing);
break;
case "Utilities_Cancel":
await context.EmitEventAsync(Constants.Event_Cancel);
break;
case "Utilities_GoBack":
await context.EmitEventAsync(Constants.Event_Cancel);
break;
case "Utilities_Reject":
await context.EmitEventAsync(Constants.Event_Reject);
break;
case "ValueTrade":
await SendInterest(context, Constants.INTEREST_TradeIn);
break;
default:
//New intent?
break;
}
return(new DialogTurnResult(DialogTurnStatus.Complete, null));
}
private async Task <DialogTurnResult> InitialStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
RecognizerResult result = await _botServices.Dispatch.RecognizeAsync(stepContext.Context, cancellationToken);
LuisResult luisResult = result.Properties["luisResult"] as LuisResult;
if (luisResult.Entities.Count == 0)
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text(String.Format("Please provide a company name.")), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
EntityModel companyName = _botServices.FindCompanyName(luisResult.Entities);
EntityModel year = _botServices.FindYear(luisResult.Entities);
List <EntityModel> quarterPeriod = (List <EntityModel>)_botServices.FindQuarter(luisResult.Entities);
var symbols = await _financialServices.GetSymbolsList();
var symbol = symbols.symbolsList.Find(symbolObject => symbolObject.Name.Contains(companyName.Entity, StringComparison.OrdinalIgnoreCase) || symbolObject.SymbolId.Equals(companyName.Entity, StringComparison.OrdinalIgnoreCase));
if (symbol != null)
{
if (quarterPeriod.Exists(periodEntity => periodEntity.Entity.Equals("quarter", StringComparison.OrdinalIgnoreCase)))
{
var symbolFinancialData = await _financialServices.GetQuarterlyFinancialData(symbol.SymbolId, Int32.Parse(year?.Entity ?? DateTime.Now.Year.ToString()), quarterPeriod.Find(periodEntity => !periodEntity.Entity.Equals("quarter", StringComparison.OrdinalIgnoreCase)));
if (symbolFinancialData != null && symbolFinancialData.Revenue != "")
{
if (!symbolFinancialData.Date.Contains(year?.Entity ?? DateTime.Now.Year.ToString()))
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text(String.Format("Financial data of {0} is not yet available for year {1}", symbol.Name, DateTime.Now.Year.ToString())), cancellationToken);
}
await stepContext.Context.SendActivityAsync(MessageFactory.Text(String.Format("Revenue of {0} in the {1} quarter of {2} is {3} million", symbol.Name, quarterPeriod.Find(periodEntity => !periodEntity.Entity.Equals("quarter", StringComparison.OrdinalIgnoreCase)).Entity, DateTime.Parse(symbolFinancialData.Date).Year, Double.Parse(symbolFinancialData.Revenue) / 1000000)), cancellationToken);
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text(String.Format("No financial data available for {0} in the year {1}", symbol.Name, year.Entity)), cancellationToken);
}
}
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text(String.Format("Please enter a valid company name.")), cancellationToken);
}
return(await stepContext.NextAsync(null, cancellationToken));
}
private INTENT primaryIntent(RecognizerResult luisResult)
{
if (luisResult.Intents.GetValue("Places.FindPlace") != null)
{
return(INTENT.PLACES__FIND_PLACE);
}
if (luisResult.Intents.GetValue("Utilities.ShowPrevious") != null)
{
return(INTENT.UTILITIES__SHOW_PREVIOUS);
}
if (luisResult.Intents.GetValue("Utilities.ShowNext") != null)
{
return(INTENT.UTILITIES__SHOW_NEXT);
}
return(INTENT.NONE);
}
/// <summary>
/// Sends a message for the findResponse intent.
/// </summary>
/// <returns>A <see cref="Task"/> that represents the work queued to execute.</returns>
/// <param name="turnContext">A <see cref="ITurnContext"/> containing all the data needed
/// for processing this conversation turn. </param>
/// <param name="recognizerResult">A <see cref="RecognizerResult"/> containing the refined
/// data returned by LUIS.</param>
/// <param name="cancellationToken">(Optional) A <see cref="CancellationToken"/> that can be used by other objects
/// or threads to receive notice of cancellation.</param>
private async Task SendFindGeneResponseAsync(ITurnContext turnContext, RecognizerResult recognizerResult, CancellationToken cancellationToken)
{
var text = turnContext.Activity.Text;
var reply = turnContext.Activity.CreateReply();
reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
foreach (var entity in recognizerResult.Entities)
{
Luis.Response deserializedEntity;
try
{
deserializedEntity = JsonConvert.DeserializeObject <Luis.Response>(entity.Value.ToString());
}
catch
{
continue;
}
var query = string.Join(' ',
deserializedEntity.Genes.Select(x => x.Text)
.Concat(deserializedEntity.Variants.Select(x => x.Text))
.Concat(deserializedEntity.TumorTypes.Select(x => x.Text))
.Concat(deserializedEntity.TissueTypes.Select(x => x.Text)));
_telemetryClient.TrackTrace($"Find Gene -- Text sent: '{text}', query: '{query}'");
var interpretations = (await _pmkbApi.Interpretations.SearchAsync(query)).Results.Interpretations;
_telemetryClient.TrackTrace($"{interpretations.Count()} Interpretations returned by PMKB API: {JsonConvert.SerializeObject(interpretations)}");
reply.Text = $"{Resources.Prompts.Found} {interpretations.Count()} {Resources.Prompts.InterpretationsAssociatedWith} \"{text}\"";
var sortedInterpretations = interpretations.OrderByDescending(x => x.GetRelevanceScore(query)).ToList();
foreach (var i in sortedInterpretations.Take(10))
{
reply.Attachments.Add(GetInterpretationCard(text, i));
}
if (interpretations.Count() > 10)
{
reply.Attachments.Add(GetReadMoreCard(text, query, interpretations));
}
await turnContext.SendActivityAsync(reply, cancellationToken);
}
}
private RecognizerResult BuildRecognizerResultFromLuisResult(LuisResult luisResult, string utterance)
{
var recognizerResult = new RecognizerResult
{
Text = utterance,
AlteredText = luisResult.AlteredQuery,
Intents = LuisUtil.GetIntents(luisResult),
Entities = LuisUtil.ExtractEntitiesAndMetadata(luisResult.Entities, luisResult.CompositeEntities, PredictionOptions.IncludeInstanceData ?? true, utterance),
};
LuisUtil.AddProperties(luisResult, recognizerResult);
if (IncludeAPIResults)
{
recognizerResult.Properties.Add("luisResult", luisResult);
}
return(recognizerResult);
}
public static string GetEntityAsString(RecognizerResult luisResult, string ValuePropertyName = "text")
{
string returnValue = "";
if (luisResult != null)
{
var data = luisResult.Entities as IDictionary <string, JToken>;
if (data.TryGetValue(ValuePropertyName, out JToken value))
{
if (value.First != null)
{
returnValue = value.First.ToString();
}
}
}
return(returnValue);
}
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default)
{
BotAssert.ContextNotNull(turnContext);
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var utterance = turnContext.Activity.AsMessageActivity().Text;
if (!string.IsNullOrWhiteSpace(utterance))
{
RecognizerResult luisRecognizerResult =
await _luisRecognizer.RecognizeAsync(turnContext, CancellationToken.None).ConfigureAwait(false);
turnContext.TurnState.Add("LuisRecognizerResult", luisRecognizerResult);
}
}
await next(cancellationToken).ConfigureAwait(false);
}
public void TrackIntent(
IActivity activity,
RecognizerResult recognizerResult)
{
var(intent, score) = recognizerResult.GetTopScoringIntent();
var properties = new Dictionary <string, string>
{
{ TelemetryEventProperties.IntentProperty, intent },
{ TelemetryEventProperties.ScoreProperty, score.ToString("N2") },
{ TelemetryEventProperties.EntitiesProperty, JsonConvert.SerializeObject(recognizerResult.Entities) },
};
var et = BuildEventTelemetry(activity, properties);
et.Name = TelemetryEventTypes.Intent;
telemetryClient.TrackEvent(et);
// TODO: Track sentiment if included in intent data.
}
private async Task IntentNone(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
var resultQnA = await _qnaMakerAIService._qnaMakerResult.GetAnswersAsync(stepContext.Context);
var score = resultQnA.FirstOrDefault()?.Score; // Capturo el puntaje
string response = resultQnA.FirstOrDefault()?.Answer; // Capturo la respuesta que devuelve Qna Maker
if (score >= 0.5)
{
await stepContext.Context.SendActivityAsync(response, cancellationToken : cancellationToken);
await buttonsInicio(stepContext, cancellationToken, $"En que te puedo ayudar?");
}
else
{
await Task.Delay(500);
await buttonsInicio(stepContext, cancellationToken, $"No entiendo lo que me dices, puedes utilizar los botones de la parte inferior.");
}
}
private async Task IntentPocho(WaterfallStepContext stepContext, RecognizerResult luisResult, CancellationToken cancellationToken)
{
await stepContext.Context.SendActivityAsync("Si ha estado en contacto estrecho con alguien con COVID 19, puede estar infectado."
+ "Contacto estrecho significa vivir con alguien que tiene la enfermedad o haber estado a menos de un metro de distancia de alguien que tiene la enfermedad.En estos casos, es mejor quedarse en casa."
+ "Sin embargo, si usted vive en una zona con paludismo(malaria) o dengue, es importante que no ignore la fiebre.Busque ayuda médica.Cuando acuda al centro de salud lleve mascarilla si es posible, manténgase al menos a un metro de distancia de las demás personas y no toque las superficies con las manos.En caso de que el enfermo sea un niño, ayúdelo a seguir este consejo."
+ "Si no vive en una zona con paludismo(malaria) o dengue, por favor haga lo siguiente:"
+ "Si enferma, incluso con síntomas muy leves como fiebre y dolores leves, debe aislarse en su casa."
+ " - Incluso si no cree haber estado expuesto a la COVID 19 pero desarrolla estos síntomas, aíslese y controle su estado."
+ " - Es más probable que infecte a otros en las primeras etapas de la enfermedad cuando solo tiene síntomas leves, por lo que el aislamiento temprano es muy importante."
+ "- Si no tiene síntomas pero ha estado expuesto a una persona infectada, póngase en cuarentena durante 14 días."
+ "Si ha tenido indudablemente COVID 19(confirmada mediante una prueba), aíslese durante 14 días incluso después de que los síntomas hayan desaparecido como medida de precaución.Todavía no se sabe exactamente cuánto tiempo las personas siguen siendo contagiosas después de recuperarse.Siga los consejos de las autoridades nacionales sobre el aislamiento.", cancellationToken : cancellationToken);
}
