/// <summary>
/// Get the Answer(s) based on the intent name. In this situation, the intent will have one or more entities that we will do a search on
/// </summary>
/// <param name="intent"></param>
/// <returns></returns>
public static async Task <List <AnswerModel> > GetAndFormatAnswer(LuisResponse intent)
{
//List<Answer> chatAnswers = new List<Answer>();
var chatAnswers = new List <AnswerModel>();
var questionInfo = await DataAccess.GetQuestion(GetHighScoringIntent(intent));
if (questionInfo.QuestionText != null)
{
chatAnswers = DataAccess.GetAnswers(questionInfo.QuestionId).Result;
//if we get back answers with AnswerTypeId = 2, then we need to do a web search. Format those answers.
if (chatAnswers.Count > 0 && chatAnswers[0].AnswerTypeId == 2)
{
if (intent.entities.Length > 0)
{
var searchString = intent.entities[0].entity;
for (int i = 1; i < intent.entities.Length; i++)
{
searchString += $" {intent.entities[i].entity}";
}
chatAnswers[0].AnswerText = GetGoogleSearchMessage(searchString);
}
}
}
return(chatAnswers);
}
/// <summary>
/// Enumerates and returns additional entities returned by LUIS.
/// </summary>
/// <param name="luisResponse">The response from LUIS.</param>
/// <param name="log">A logger instance.</param>
/// <returns>A dictionary representing the additional entities.</returns>
public Dictionary<string, string> EnumerateAdditionalEntities(LuisResponse luisResponse, ILogger log)
{
if (luisResponse.Entities == null)
{
return null;
}
IList<LuisEntity> extraEntities = luisResponse
.Entities
.Where(x => !_expectedEntities.Contains(x.Type))
.ToList();
Dictionary<string, string> extraEntitiesDictionary = new Dictionary<string, string>();
int keySuffixNumber = 1;
foreach (LuisEntity entity in extraEntities)
{
string key = entity.Type;
while (extraEntitiesDictionary.ContainsKey(key))
{
key = $"{key}-{++keySuffixNumber}";
}
extraEntitiesDictionary.Add(key, entity.Entity);
}
return extraEntitiesDictionary;
}
public ConversationResponse ProcessInContext(LuisResponse response)
{
if (!IsConnected)
{
return(ConnectPath(response));
}
if (SelectedEntity == null)
{
return(EntityPath(response));
}
var unsetEntity = CheckUnsetEntity(response);
if (unsetEntity != null)
{
return(unsetEntity);
}
var setFilter = CheckSetFilter(response);
if (setFilter != null)
{
return(setFilter);
}
var unsetFilter = CheckUnsetFilter(response);
if (unsetFilter != null)
{
return(unsetFilter);
}
return(new ConversationResponse(""));
}
private void HandleIntent(LuisResponse intent, MessageType msgObj)
{
var primaryIntent = intent.topScoringIntent;
var primaryEntity = intent.entities.FirstOrDefault();
if (primaryIntent != null && primaryEntity != null)
{
if (primaryIntent.intent.Equals("OrderIn") && primaryIntent.score > 0.75)
{
//Detected an actionable request with an identified entity
if (primaryEntity != null && primaryEntity.score > 0.5)
{
String destination = primaryEntity.type.Equals("RoomService::FoodItem") ? "Room Service" : "Housekeeping";
String generatedMessage = string.Format("We've sent your request for {0} to {1}, we will confirm it shortly.", primaryEntity.entity, destination);
SendBotMessage(msgObj, generatedMessage);
}
else
{
//Detected only an actionable request, but no entity
String generatedMessage = "We've received your request for service, our staff will followup momentarily.";
SendBotMessage(msgObj, generatedMessage);
}
}
}
}
/// <summary>
/// Extracts person information from the transcript.
/// </summary>
/// <param name="luisResponse">The transcript.</param>
/// <param name="log">Trace logging instance.</param>
/// <returns>The extracted person information.</returns>
public PersonInfo ExtractPerson(LuisResponse luisResponse, ILogger log)
{
PersonInfo personInfo = null;
if (luisResponse.Entities == null
|| luisResponse.Entities.Count == 0)
{
return personInfo;
}
LuisEntity personEntity = luisResponse
.Entities
.Where(x => x.Type == _config.PersonEntityName)
.FirstOrDefault();
if (personEntity != null)
{
personInfo = new PersonInfo()
{
Name = personEntity.Entity,
Type = luisResponse.TopScoringIntent != null
? (_config.PersonIntentTypeMap.ContainsKey(luisResponse.TopScoringIntent.Intent) ? _config.PersonIntentTypeMap[luisResponse.TopScoringIntent.Intent] : "Unknown")
: "Unknown",
};
}
return personInfo;
}
private static async Task HandleIntent(LuisResponse intent, MessageType msgObj, IAsyncCollector <BrokeredMessage> outputServiceBus)
{
var primaryIntent = intent.topScoringIntent;
var primaryEntity = intent.entities.FirstOrDefault();
if (primaryIntent != null && primaryEntity != null)
{
if (primaryIntent.intent.Equals("OrderIn") && primaryIntent.score > 0.75)
{
//Detected an actionable request with an identified entity
if (primaryEntity != null && primaryEntity.score > 0.5)
{
var destination = primaryEntity.type.Equals("RoomService::FoodItem") ? "Room Service" : "Housekeeping";
var generatedMessage =
$"We've sent your request for {primaryEntity.entity} to {destination}, we will confirm it shortly.";
await SendBotMessage(msgObj, generatedMessage, outputServiceBus);
}
else
{
//Detected only an actionable request, but no entity
var generatedMessage = "We've received your request for service, our staff will followup momentarily.";
await SendBotMessage(msgObj, generatedMessage, outputServiceBus);
}
}
}
}
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
switch (turnContext.Activity.Type)
{
case ActivityTypes.Message:
var luisResult = turnContext.TurnState.Get <RecognizerResult>(LuisRecognizerMiddleware.LuisRecognizerResultKey);
var luisResponse = new LuisResponse();
luisResponse.Convert(luisResult);
if (luisResult != null)
{
await turnContext.SendActivityAsync($"Your input message after translation is " + luisResponse.Text);
var topItem = luisResponse.TopIntent();
await turnContext.SendActivityAsync($"After using LUIS recognition:\nthe top intent was: {topItem.intent}, with score {topItem.score}");
}
break;
case ActivityTypes.ConversationUpdate:
foreach (var newMember in turnContext.Activity.MembersAdded)
{
if (newMember.Id != turnContext.Activity.Recipient.Id)
{
await turnContext.SendActivityAsync("Hello and welcome to the Luis Sample bot.");
}
}
break;
}
}
private async Task HandleWeatherIntent(IDialogContext context, LuisResponse intent, bool showWeekendInfo)
{
if (intent.entities.Length > 0)
{
var location = string.Empty;
//check to see if we just have a city, or a city and a state.
if (intent.entities.Length == 2)
{
location = intent.entities[0].entity + "," + intent.entities[1].entity;
}
else
{
location = intent.entities[0].entity;
}
await GetDisplayWeatherInfo(context, location, showWeekendInfo);
}
else
{
context.UserData.SetValue("intentName", intent.topScoringIntent.intent);
PromptDialog.Text(
context: context,
resume: CheckWeatherUserInfo,
prompt: "What city would you like the weather for? Enter in the City/State or Zip Code for the intended area.",
retry: "Sorry, I didn't understand that. Please try again."
);
}
}
protected virtual async Task AfterBirthdayEntry(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var message = await result;
context.ConversationData.SetValue <string>("INSURANCE-BIRTHDAY", message.Text);
LuisResponse luisInfo = await ServiceProxies.GetEntityFromLUIS(message.Text);
if (luisInfo.intents != null && luisInfo.intents.Length > 0 && luisInfo.intents[0].score > 0.6 && luisInfo.intents[0].intent == "Abort")
{
await context.PostAsync("Ok, sorry, wir hören jetzt auf. Vielleicht ein anderes mal!");
context.Done <string>(null);
}
else
{
string birthday = message.Text;
string insuranceNumber = context.ConversationData.GetValue <string>("INSURANCE-NUMBER");
string insuranceName = context.ConversationData.GetValue <string>("INSURANCE-NAME");
System.Diagnostics.Trace.TraceInformation($"KREDITABL {insuranceNumber} - {insuranceName} - {birthday}");
await context.PostAsync($"Vielen Dank, Ihre Kreditablöseinformation ist unterwegs!");
context.Done <string>(null);
}
}
private static async Task <LuisResponse> GetEntityFromConginitiveService(string text)
{
LuisResponse Data = new LuisResponse();
try
{
text = Uri.EscapeDataString(text);
using (HttpClient client = new HttpClient())
{
var responseInString = await client.GetStringAsync(@"https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/59583dde-cc2f-4554-b004-db3bae7e9b8a?subscription-key=4939782dc2df43fbb61a67154a79a30a&staging=true&verbose=true&timezoneOffset=-360&q="
+ System.Uri.EscapeDataString(text));
Data = JsonConvert.DeserializeObject <LuisResponse>(responseInString);
//if (msg.IsSuccessStatusCode)
//{
// var JsonDataResponse = await msg.Content.ReadAsStringAsync();
//}
}
}
catch (Exception ex)
{
//ErrorLog.ErrorLogging("", ex.Message, "", DateTime.Now);
throw ex;
}
return(Data);
}
private void HandleIntent(LuisResponse intent, MessageType msgObj)
{
var primaryIntent = intent.topScoringIntent;
var primaryEntity = intent.entities.FirstOrDefault();
if (primaryIntent != null && primaryEntity != null)
{
if (primaryIntent.intent.Equals("PlaceOrder") && primaryIntent.score > 0.75)
{
//Detected an actionable request with an identified entity
if (primaryEntity != null && primaryEntity.score > 0.5)
{
//TODO: Process request for identified entity
String destination = primaryEntity.type.Equals("PoolService::FoodItem")
? "the bartender has been notified"
: "unknown request";
String generatedMessage = string.Format("We have sent your request {0} to {1}",
primaryEntity.entity, destination);
SendBotMessage(msgObj, generatedMessage);
}
else
{
//TODO: Process request generically
String generatedMessage = "We have received your request for service";
SendBotMessage(msgObj, generatedMessage);
}
}
}
}
public async Task <LuisResponse> GetUserIntent(string query)
{
using (var client = new HttpClient {
BaseAddress = new Uri(Configuration.LuisBaseAddress)
})
{
var response = await client.GetAsync($"{Configuration.LuisAppId}?subscription-key={Configuration.LuisApiKey}&q={query}");
if (!response.IsSuccessStatusCode)
{
if (response.Content != null)
{
throw new WebException($"Server error {response.StatusCode} - {await response.Content.ReadAsStringAsync()}");
}
throw new Exception($"Server error {response.StatusCode}");
}
else
{
var luisResponseDto = await response.Content.ReadAsAsync <LuisResponseDto>();
var luisResponse = new LuisResponse
{
UserIntent = (UserIntent)Enum.Parse(typeof(UserIntent), luisResponseDto.topScoringIntent.intent),
Entities = luisResponseDto.entities.Select(e => e.entity).ToList()
};
return(luisResponse);
}
}
// var client = new RestClient( Configuration.LuisBaseAddress );
// var request = new RestRequest( Configuration.LuisAppId, Method.GET );
// request.AddParameter( "subscription-key", Configuration.LuisApiKey, ParameterType.QueryString );
// request.AddParameter( "q", query, ParameterType.QueryString );
// var response = await client.ExecuteGetTaskAsync<LuisResponseDto>( request );
// if (response.ResponseStatus != ResponseStatus.Completed)
// {
// throw new WebException( response.ErrorMessage, response.ErrorException );
// }
// var luisResponse = new LuisResponse
// {
// UserIntent = (UserIntent)Enum.Parse( typeof( UserIntent ), response.Data.topScoringIntent.intent ),
// Entities = response.Data.entities.Select( e => e.entity ).ToList()
// };
// return luisResponse;
}
private ConversationResponse CheckUnsetEntity(LuisResponse response)
{
if (response.topScoringIntent?.intent == UnsetEntity)
{
this.SelectedEntity = null;
return(new ConversationResponse("Seleccione otra entidad"));
}
return(null);
}
private static string[] ExtractV1TimeEntities(ChatState state, LuisResponse luisResponse)
{
LuisDateParser parser = new LuisDateParser(state.GetUserTimeZoneOffset());
var luisTimes = parser.ParseLuisTimes(luisResponse.Entities);
return((from time in luisTimes
where time.Time != null
select time.Time.Format12Hour).ToArray());
}
private async Task <string> ParseLuisResponse(LuisResponse luisResponse)
{
Intent winner = luisResponse.Winner();
if (winner == null || winner.IsNone())
{
return(Sad);
}
return(luisResponse.Winner().Name);
}
public async void MakeRequest(object sender, EventArgs e)
{
var client = new HttpClient();
var queryString = HttpUtility.ParseQueryString(string.Empty);
// This app ID is for a public sample app that recognizes requests to turn on and turn off lights
var luisAppId = "<replace with your LUIS App ID here>";
var subscriptionKey = "<replace with your LUIS subscription Key here>";
// The request header contains your subscription key
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
// The "q" parameter contains the utterance to send to LUIS
queryString["q"] = txtMessage.Text;
// These optional request parameters are set to their default values
queryString["timezoneOffset"] = "0";
queryString["verbose"] = "false";
queryString["spellCheck"] = "false";
queryString["staging"] = "false";
var uri = "https://southeastasia.api.cognitive.microsoft.com/luis/v2.0/apps/" + luisAppId + "?" + queryString; //remember to change to the region that you set in LUIS.ai
var response = await client.GetAsync(uri);
var strResponseContent = await response.Content.ReadAsStringAsync();
//// Display the JSON result from LUIS
//Console.WriteLine(strResponseContent.ToString());
try
{
lblIntent.Text = "";
lblEntities.Text = "";
LuisResponse luisResponse = JsonConvert.DeserializeObject <LuisResponse>(strResponseContent);
if (luisResponse != null)
{
if (luisResponse.topScoringIntent != null)
{
lblIntent.Text = luisResponse.topScoringIntent.intent;
}
if (luisResponse.entities.Count() > 0)
{
foreach (var entities in luisResponse.entities)
{
lblEntities.Text += entities.entity + "(" + entities.type + ")\n";
}
}
}
}catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public async Task <LuisResponse> LuisDetectDateTime([ActivityTrigger] IDurableActivityContext context, ILogger log)
{
var message = context.GetInput <string>();
log.LogInformation("Calling Luis to detect time.");
using var httpClient = _httpClientFactory.CreateClient();
var luisJsonResponse = await httpClient.GetStringAsync(string.Format(_options.LuisUrl, message));
return(LuisResponse.Parse(luisJsonResponse));
}
private DateTimeParseResult[] ExtractDateResults(ChatState chatState, LuisResponse luisResponse, bool assumeFuture)
{
LuisDateParser parser = new LuisDateParser(chatState.GetUserTimeZoneOffset());
if (luisResponse?.Entities.Length > 0)
{
return(parser.ParseLuisDates(luisResponse.Entities, assumeFuture));
}
return(null);
}
/// <summary>
/// Gets message from WPF and sends data to LUIS.ai and return json object
/// </summary>
/// <param name="utterance">the WPF user message</param>
/// <returns>A JSON Object with data to make the query to send</returns>
private async Task <LuisResponse> GetFromLuisAsync(string utterance)
{
string key = Credentials.LUIS_KEY;
string endpoint = Credentials.LUIS_URL;
string LUISAppID = Credentials.LUIS_ID;
string luisResponse = await MakeRequest(key, endpoint, LUISAppID, utterance);
LuisResponse wholeData = JsonConvert.DeserializeObject <LuisResponse>(luisResponse);
return(wholeData);
}
private void AssertResponse(LuisResponse actual, ExpectedResponse expected)
{
Assert.NotNull(actual);
Assert.NotNull(expected);
Assert.True(expected.Intent == actual.topScoringIntent.intent, "intents do not match");
var entity = actual.entities.OrderByDescending(e => e.score).FirstOrDefault();
Assert.True(entity != null, "entity should not be null!");
Assert.True(expected.EntityType == entity.@type, "entity types do not match!");
Assert.True(string.Equals(expected.EntityValue, entity.entity, StringComparison.OrdinalIgnoreCase), "entity values do not match!");
}
public static string GetHighScoringIntent(LuisResponse intent)
{
//by default set intent to None. Check response to verify that the intent is a good match
var intentName = "None";
if (intent.topScoringIntent.score > 0.6)
{
intentName = intent.topScoringIntent.intent;
}
return(intentName);
}
/// <summary>
/// Gets JSON (response data from LUIS) object and returns query as a string
/// </summary>
/// <param name="data">the response data from LUIS</param>
/// <returns></returns>
private string ConstructQueryHelper(LuisResponse data)
{
TopScoringIntent processedIntent = data.TopScoringIntent;
string actualQuery = string.Empty;
switch (processedIntent.Intent)//compose the query
{
case "None":
throw new Exception("Please paraphrase your question, couldn't understand what you meant!");
case "MachineRequestData":
List <Entity> machineEntities = data.Entities;
MachineRequestData machineRequest = new MachineRequestData();
machineRequest.SensorID = machineEntities.Find(e => e.Type == "MachineID").entity;
machineRequest.Type = machineEntities.Find(e => e.Type == "MachineRequestType").resolution.values[0];
actualQuery = JsonConvert.SerializeObject(machineRequest);
break;
default:
List <Entity> kpiEntities = data.Entities;
KPIRequestDataWithoutPart kpiRequestWithoutPart = new KPIRequestDataWithoutPart();
int buf;
kpiRequestWithoutPart.KpiType = processedIntent.Intent;
kpiRequestWithoutPart.WorkOrder = kpiEntities.Find(e => e.Type == "KPIworkOrderID" && int.TryParse(e.entity, out buf)).entity;
//get part entity
CompositeEntity kpiOrderPart = data.CompositeEntities.Find(e => (e.ParentType == "KPIrequestDataPart" && int.TryParse(e.Value, out buf)));
//filter request types without part
if (processedIntent.nonOrderQuery() && kpiOrderPart != null)
{
string kpiOrderPartValue = kpiOrderPart.Value;
if (kpiOrderPart != null)
{
string serializedKPIWithoutPart = JsonConvert.SerializeObject(kpiRequestWithoutPart);
KPIRequestDataWithPart kpiRequestWithPart = JsonConvert.DeserializeObject <KPIRequestDataWithPart>(serializedKPIWithoutPart);
kpiRequestWithPart.Part = kpiOrderPartValue;
actualQuery = JsonConvert.SerializeObject(kpiRequestWithPart);
break;
}
else
{
//couldn't find part value
throw new NullReferenceException("Couldn't find part value");
}
}
actualQuery = JsonConvert.SerializeObject(kpiRequestWithoutPart);
break;
}
return(actualQuery);
}
/// <summary>
/// Replaces all entity types that were found in the message construct by their values from the LuisResponse
/// </summary>
/// <param name="textToUpdate">The message text that should be updated. This needs to include the entity types in the format {entityType}.</param>
/// <param name="luisReponse">The LuisResponse that is used to replace the entity values from the message.</param>
private string ReplaceWithLuisEntities(string textToUpdate, LuisResponse luisResponse)
{
var newText = textToUpdate;
// TODO: What to do, when a entity is included in message, but not found in LuisResponse?
foreach (var entity in luisResponse.Entities)
{
newText = newText.Replace("{" + entity.Type + "}", entity.EntityEntity);
}
return(newText);
}
public override async Task <Message> OnMessage()
{
if (Message.Text.Equals(Hi, StringComparison.InvariantCultureIgnoreCase))
{
return(Message.CreateReplyMessage(Sample));
}
LuisResponse luisResponse = await _luisClient.SendQuery(Message.Text);
string result = await ParseLuisResponse(luisResponse);
return(Message.CreateReplyMessage(result));
}
/// <summary>
/// Extracts date and time information from the transcript.
/// </summary>
/// <param name="luisResponse">The transcript.</param>
/// <param name="log">Trace logging instance.</param>
/// <returns>The extracted date and time information.</returns>
public List<DateInfo> ExtractDateTimes(LuisResponse luisResponse, ILogger log)
{
List<DateInfo> dateInfos = new List<DateInfo>();
if (luisResponse.Entities == null
|| luisResponse.Entities.Count == 0)
{
return dateInfos;
}
dateInfos.AddRange(GetDateInfos(luisResponse.Entities));
return dateInfos;
}
private static async Task <LuisResponse> GetIntentAndEntities(string messageText)
{
LuisResponse result = null;
string queryUri = string.Format(_luisQueryParams, _luisAppId, _luisKey, Uri.EscapeDataString(messageText));
HttpResponseMessage response = await _intentClient.GetAsync($"{_luisBaseUrl}/{queryUri}");
string res = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <LuisResponse>(res);
Console.WriteLine("\nLUIS Response:\n" + res);
return(result);
}
public void DoAction(LuisResponse luis)
{
if (luis.TopScoringIntent.Intent == "TurnOnTv")
{
TurnOn(luis.Entities.OrderByDescending(e => e.Score).FirstOrDefault());
}
if (luis.TopScoringIntent.Intent == "FullScreenTv")
{
IsFullscreen = true;
}
if (luis.TopScoringIntent.Intent == "ReduceScreenTv")
{
IsFullscreen = false;
}
}
protected virtual async Task StartKreditAblöseDialog(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var input = await result;
LuisResponse luisInfo = await ServiceProxies.GetEntityFromLUIS(input.Text);
if (luisInfo.intents.Length > 0 && luisInfo.intents[0].intent == "Ja")
{
// Yes start kreditablösedialog
IDialog <string> kreditDialog = (IDialog <string>) new KreditAblöseDialog();
context.Call(kreditDialog, AfterKreditDialog);
}
else
{
context.Wait(MessageReceivedAsync);
}
}
private LuisResponseModel ParseResponse(LuisResponse luisResponse)
{
var model = new LuisResponseModel();
foreach (var entity in luisResponse.entities)
{
if (!String.IsNullOrWhiteSpace(entity.role))
{
model.Name = entity.role;
}
if (entity.resolution != null)
{
model.Value = entity.resolution.value;
}
}
return(model);
}
private async Task <LuisResponse> GetIntentAndEntities(string messageText)
{
LuisResponse result = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_luisBaseUrl);
string queryUri = string.Format(_luisQueryParams, _luisAppId, _luisKey, Uri.EscapeDataString(messageText));
HttpResponseMessage response = await client.GetAsync(queryUri);
string res = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <LuisResponse>(res);
Console.WriteLine("\nLUIS Response:\n" + res);
}
return(result);
}
