private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
Console.WriteLine("+++++++FinalStepAsync+++++++++++");
var message = (string)stepContext.Result;
string status = "🎊🎊🎊 The game ends, " + message + "! 🎊🎊🎊";
await stepContext.Context.SendActivityAsync(status);
var accessor = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var gameData = await accessor.GetAsync(stepContext.Context, () => new ConversationData());
await stepContext.Context.SendActivityAsync("What to know who were the special players?");
foreach (var pair in gameData.RoleToUsers)
{
Logger.LogInformation("The role is {0}", pair.Key);
if (pair.Key != Role.Villager.ToString())
{
var roleNames = pair.Value.Select(pid => gameData.UserProfileMap.GetValueOrDefault(pid, pid));
await stepContext.Context.SendActivityAsync($"{pair.Key}: {string.Join(", ", roleNames)}");
}
}
// await stepContext.Context.SendActivityAsync($"{player.Name}: {player.Role.ToString()}");
// Clean up the Property Data
await accessor.SetAsync(stepContext.Context, new ConversationData(), cancellationToken);
await _conversationState.SaveChangesAsync(stepContext.Context, false, cancellationToken);
return(await stepContext.EndDialogAsync("Official End", cancellationToken));
}
public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
await base.OnTurnAsync(turnContext, cancellationToken);
await _conversationState.SaveChangesAsync(turnContext, false, cancellationToken);
await _userState.SaveChangesAsync(turnContext, false, cancellationToken);
}
public override async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
await base.OnTurnAsync(turnContext, cancellationToken);
// Save any state changes that might have occurred during the turn.
await ConversationState.SaveChangesAsync(turnContext, false, cancellationToken);
await UserState.SaveChangesAsync(turnContext, false, cancellationToken);
}
/// <summary>
/// Every conversation turn for our Basic Bot will call this method.
/// </summary>
/// <param name="turnContext">A <see cref="ITurnContext"/> containing all the data needed
/// for processing this conversation turn. </param>
/// <param name="cancellationToken">(Optional) A <see cref="CancellationToken"/> that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> that represents the work queued to execute.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
// See https://aka.ms/about-bot-activity-message to learn more about message and other activity types.
switch (turnContext.Activity.Type)
{
case ActivityTypes.Message:
// Process on turn input (card or NLP) and gather new properties.
// OnTurnProperty object has processed information from the input message activity.
var onTurnProperties = await DetectIntentAndEntitiesAsync(turnContext);
if (onTurnProperties == null)
{
break;
}
// Set the state with gathered properties (intent/ entities) through the onTurnAccessor.
await _onTurnAccessor.SetAsync(turnContext, onTurnProperties);
// Create dialog context.
var dc = await _dialogs.CreateContextAsync(turnContext);
// Continue outstanding dialogs.
await dc.ContinueDialogAsync();
// Begin main dialog if no outstanding dialogs/ no one responded.
if (!dc.Context.Responded)
{
await dc.BeginDialogAsync(nameof(MainDispatcher));
}
break;
case ActivityTypes.ConversationUpdate:
if (turnContext.Activity.MembersAdded != null)
{
await SendWelcomeMessageAsync(turnContext);
}
break;
default:
// Handle other activity types as needed.
await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected");
break;
}
await ConversationState.SaveChangesAsync(turnContext);
await UserState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
// QnA//
await QnAResponse(turnContext, cancellationToken);
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Recognize what the user said.
var topIntent = await GreetingHelpCancelRecognizer(turnContext, cancellationToken);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// See if LUIS found and used an entity to determine user intent.
var entityFound = ParseLuisForEntities(luisResults);
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
//await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
case BuyIntent:
//await dc.Context.SendActivityAsync(topIntent);
// Inform the user if LUIS used an entity.
if (entityFound.ToString() != string.Empty)
{
string[] cutEntity = entityFound.Split("|SEP|");
//await turnContext.SendActivityAsync($"==>LUIS String: {entityFound}\n");
int count = 0;
bool entityCheck = false;
foreach (var cutEntityValue in cutEntity)
{
if (cutEntityValue != string.Empty)
{
count++;
if (count == 3)
{
entityCheck = true;
}
}
}
if (entityCheck)
{
/*
* foreach (var cutEntityValue in cutEntity)
* {
* await turnContext.SendActivityAsync($"==>LUIS Entity: {cutEntityValue}\n");
* }
* await turnContext.SendActivityAsync($"==>LUIS Entity Found: {entityFound}\n");
*/
/*
* // 카드는 html에서 출력
* var buyCard = CreateBuyCardAttachment(@".\Dialogs\BuyIntent\Resources\buyCard.json", entityFound);
* var response = CreateResponse(activity, buyCard);
* await dc.Context.SendActivityAsync(response);
*/
// html에 인텐트+엔티티 전달
Activity buyReply = activity.CreateReply();
buyReply.Type = ActivityTypes.Event;
buyReply.Name = "buystock";
buyReply.Value = entityFound.ToString();
await dc.Context.SendActivityAsync(buyReply);
}
else
{
await turnContext.SendActivityAsync($"종목, 수량, 단가를 모두 입력해주세요.\n(예시:\"신한지주 1주 현재가로 매수해줘\")");
}
}
else
{
await turnContext.SendActivityAsync($"종목, 수량, 단가를 모두 입력해주세요.\n(예시:\"신한지주 1주 현재가로 매수해줘\")");
}
break;
case SellIntent:
//await dc.Context.SendActivityAsync(topIntent);
// Inform the user if LUIS used an entity.
if (entityFound.ToString() != string.Empty)
{
string[] cutEntity = entityFound.Split("|SEP|");
//await turnContext.SendActivityAsync($"==>LUIS Count: {cutEntity.Length}\n");
foreach (var cutEntityValue in cutEntity)
{
//await turnContext.SendActivityAsync($"==>LUIS Entity: {cutEntityValue}\n");
}
//await turnContext.SendActivityAsync($"==>LUIS Entity Found: {entityFound}\n");
/*
* // 카드는 html에서 출력
* var sellCard = CreateSellCardAttachment(@".\Dialogs\BuyIntent\Resources\buyCard.json", entityFound);
* var sell_response = CreateResponse(activity, sellCard);
* await dc.Context.SendActivityAsync(sell_response);
*/
// html에 인텐트+엔티티 전달
Activity sellReply = activity.CreateReply();
sellReply.Type = ActivityTypes.Event;
sellReply.Name = "sellstock";
sellReply.Value = entityFound.ToString();
await dc.Context.SendActivityAsync(sellReply);
}
else
{
await turnContext.SendActivityAsync($"종목, 수량, 단가를 모두 입력해주세요.\n(예시:\"신한지주 1주 현재가로 매도해줘\")");
}
break;
case BalanceIntent:
//await dc.Context.SendActivityAsync(topIntent);
// html에 인텐트+엔티티 전달
Activity balanceReply = activity.CreateReply();
balanceReply.Type = ActivityTypes.Event;
balanceReply.Name = "balancestock";
balanceReply.Value = entityFound.ToString();
await dc.Context.SendActivityAsync(balanceReply);
break;
case SkinBalanceIntent:
// html에 인텐트+엔티티 전달
Activity balanceSkinReply = activity.CreateReply();
balanceSkinReply.Type = ActivityTypes.Event;
balanceSkinReply.Name = "balanceskin";
balanceSkinReply.Value = entityFound.ToString();
await dc.Context.SendActivityAsync(balanceSkinReply);
// 잔고인텐트 일때는 잔고 카드 전달
var balanceCard = CreateWelcomeCardAttachment(@".\Dialogs\BalanceIntent\Resources\balanceCard.json");
var response = CreateResponse(activity, balanceCard);
await dc.Context.SendActivityAsync(response);
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id == activity.Recipient.Id)
{
var welcomeCard = CreateWelcomeCardAttachment(@".\Dialogs\Welcome\Resources\welcomeCard.json");
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
if (activity.Attachments != null && activity.Attachments.Any())
{
// We know the user is sending an attachment as there is at least one item
// in the Attachments list.
await HandleIncomingAttachmentAsync(dc, activity);
return;
}
if (activity.Text?.Trim()?.ToLowerInvariant() == "hi")
{
await turnContext.SendActivitiesAsync(
new IActivity[]
{
new Activity(type: ActivityTypes.Message, text: "Hi! 🙋"),
new Activity(type: ActivityTypes.Message, text: "Send me a picture of a handwritten digit and I'll tell you what the number is!"),
new Activity(type: ActivityTypes.Message, text: "Yeah, I'm that smart! 😎"),
},
cancellationToken);
}
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken).ConfigureAwait(false);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case PruebaIntent:
await dc.BeginDialogAsync(nameof(PruebaDialog));
break;
case TransactionIntent:
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response).ConfigureAwait(false);
break;
case NoneIntent:
default:
await dc.Context.SendActivityAsync("Disculpa, No te entendí lo que me quieres decir");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded.Any())
{
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
this.turnContextResolverService.UpdateTurnContext(turnContext);
await this.userState.LoadAsync(turnContext);
var activity = turnContext.Activity;
// Create a dialog context
var dialogContext = await Dialogs.CreateContextAsync(turnContext);
try
{
if (activity.Type == ActivityTypes.Message)
{
// Continue the current dialog
var dialogResult = await dialogContext.ContinueDialogAsync();
// if no one has responded,
if (!dialogContext.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await services.LuisServices[LuisConfiguration].RecognizeAsync(dialogContext.Context, cancellationToken);
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = this.Intents.FirstOrDefault(i => i.Id == topScoringIntent.Value.intent);
if (topIntent == null)
{
await dialogContext.Context.SendActivityAsync(MessageConstants.MessageNotUnderstood);
}
else
{
var parsedEntities = this.ParseEntities(luisResults);
await dialogContext.BeginDialogAsync(topIntent.DialogId, parsedEntities);
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
default:
await dialogContext.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
if (member.Id != activity.Recipient.Id)
{
var userTokens = await this.stateBotAccessors.UserTokensAccessor.GetAsync(turnContext, () => new TokensModel());
if (userTokens.IsAuthenticated)
{
// Send options for what the bot can do through adaptive cards for example
}
else
{
await dialogContext.BeginDialogAsync(nameof(LoginDialog));
}
}
}
}
}
}
catch (Exception ex)
{
await dialogContext.CancelAllDialogsAsync();
await turnContext.SendActivityAsync(ex.Message);
}
await conversationState.SaveChangesAsync(turnContext);
await userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
if (activity.Text == null && activity.Value != null)
{
turnContext.Activity.Text = turnContext.Activity.Value.ToString();
}
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
var utterance = turnContext.Activity.Text;
UtteranceLog logItems = null;
// see if there are previous messages saved in sstorage.
string[] utteranceList = { "UtteranceLog" };
//logItems = _myStorage.ReadAsync<UtteranceLog>(utteranceList).Result?.FirstOrDefault().Value;
// If no stored messages were found, create and store a new entry.
if (logItems is null)
{
logItems = new UtteranceLog();
}
// add new message to list of messages to display.
logItems.UtteranceList.Add(utterance);
// increment turn counter.
logItems.TurnNumber++;
var changes = new Dictionary <string, object>();
// show user new list of saved messages.
//await turnContext.SendActivityAsync($"The list is now: {string.Join(", ", logItems.UtteranceList)}");
// Create Dictionary object to hold new list of messages.
{
changes.Add("UtteranceLog", logItems);
};
// Save new list to your Storage.
await _myStorage.WriteAsync(changes, cancellationToken);
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken).ConfigureAwait(false);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
//await UpdateGreetingState(luisResults, dc.Context);
await UpdateMedicState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(MedicDialog));
break;
case MedicIntent:
await dc.BeginDialogAsync(nameof(MedicDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded.Any())
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response).ConfigureAwait(false);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Remove the bot mention to avoid issues with LUIS's NLP
dc.Context.Activity.RemoveRecipientMention();
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken).ConfigureAwait(false);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
// await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// for testing to view list of jobs. TODO: clean up
var text = turnContext.Activity.Text.Trim().ToLowerInvariant();
switch (text)
{
case "show":
case "show jobs":
await _jobService.ListJobs(turnContext);
break;
default:
break;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.Context.SendActivityAsync("Hello, this is Niles, your DevOps ChatBot assistant");
break;
case CreateIssueIntent:
await dc.BeginDialogAsync(nameof(CreateIssueDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
await DisplayHelp(dc.Context);
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
// Debugging purposes. Remove Later
await dc.Context.SendActivityAsync("Conversation Update occured");
if (activity.MembersAdded.Any())
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Debugging purposes. Remove Later
await dc.Context.SendActivityAsync($"Member joined {member.Name} with id: {member.Id}");
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment(@".\Dialogs\Welcome\Resources\welcomeCard.json");
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response).ConfigureAwait(false);
}
else
{
await dc.Context.SendActivityAsync($"Thanks for adding Niles. Type anything to get started.");
// save conversation channel
await _notificationService.StartChannel(turnContext);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Recognize what the user said.
var topIntent = await GreetingHelpCancelRecognizer(turnContext, cancellationToken);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Checks if status is currently inside QnA Maker multi turn situation
if (InQnaMaker)
{
var qnaResponse = await this.GetQnAResponse(activity.Text, turnContext);
await turnContext.SendActivityAsync(qnaResponse);
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Perform a call to LUIS to retrieve results for the current activity message.
// Until LUIS API v3 is integrated, we will call the v3 endpoint directly using a created service
var luisResults = await luisServiceV3.PredictLUIS(turnContext.Activity.Text, dc.Context);
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// loop through all the LUIS predictions, these can be single or multiple if multi-intent is enabled
foreach (var response in luisResults)
{
var topIntent = response.Intent;
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case PurchaseTicket:
var purchaseTicketResponse = laLigaBL.PurchaseTicket(response);
await turnContext.SendActivityAsync(CardHelper.GetLUISHeroCard(purchaseTicketResponse, LaLigaBL.PictureType.Ticket));
break;
case FindMatchIntent:
var findMatchResponse = laLigaBL.FindMatch(response);
await turnContext.SendActivityAsync(CardHelper.GetLUISHeroCard(findMatchResponse.ResponseText, findMatchResponse.PictureType));
break;
// Redirect to QnA if None intent is detected
case NoneIntent:
default:
var qnaResponse = await GetQnAResponse(activity.Text, turnContext);
await turnContext.SendActivityAsync(qnaResponse);
InQnaMaker = true;
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
InQnaMaker = false; // Reset QnA Maker
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
if (activity.Type == ActivityTypes.Message)
{
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(turnContext, cancellationToken).ConfigureAwait(false);
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
switch (topIntent)
{
case GreetingIntent:
await turnContext.SendActivityAsync("Hello.");
break;
case HelpIntent:
await turnContext.SendActivityAsync("Let me try to provide some help.");
await turnContext.SendActivityAsync("I understand greetings, being asked for help, or being asked to cancel what I am doing.");
break;
case CancelIntent:
await turnContext.SendActivityAsync("I have nothing to cancel.");
break;
case ReservationIntent:
await turnContext.SendActivityAsync("Reservation intent found, JSON response: " + luisResults?.Entities.ToString());
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await turnContext.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
}
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(turnContext, cancellationToken).ConfigureAwait(false);
(string intent, double score)? topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
switch (topIntent)
{
case GreetingIntent:
await turnContext.SendActivityAsync("Hello.");
break;
case HelpIntent:
await turnContext.SendActivityAsync("Let me try to provide some help.");
await turnContext.SendActivityAsync("I understand greetings, being asked for help, or being asked to cancel what I am doing.");
break;
case CancelIntent:
await turnContext.SendActivityAsync("I have nothing to cancel.");
break;
case ReservationIntent:
await turnContext.SendActivityAsync("What time do you set your reservation");
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await turnContext.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await turnContext.SendActivityAsync(response).ConfigureAwait(false);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// if an image was passed we ignorr all other input and start the cognitive service to recognize the image's contents
if (activity.Attachments != null && activity.Attachments.Count > 0)
{
var attachmentURL = activity.Attachments[0].ContentUrl;
var result = await SendImageToBeAnalyzedAndReturnDescription(attachmentURL);
await turnContext.SendActivityAsync(result);
return;
}
if (activity.Text.Contains("SpellCheck") || activity.Text.Contains("Spelling"))
{
var text = activity.Text;
HttpRequestMessage msg = new HttpRequestMessage();
msg.Headers.Add("Ocp-Apim-Subscription-Key", _configuration.GetValue <string>("bingSpellCheckKey"));
var dic = new Dictionary <string, string>();
text = text.Split("SpellCheck")[1];
dic["Text"] = text;
msg.Content = new FormUrlEncodedContent(dic);
msg.RequestUri = new Uri("https://api.cognitive.microsoft.com/bing/v7.0/spellcheck/?mode=spell");
msg.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
msg.Method = HttpMethod.Post;
var result = await _client.SendAsync(msg);
var returnObject = JsonConvert.DeserializeObject <SpellCheckModel>(await result.Content.ReadAsStringAsync());
// if No correction was found we return
if (returnObject.FlaggedTokens.Length == 0)
{
await turnContext.SendActivityAsync("Sorry coud not find any suggestions for you!");
return;
}
var bestResult = returnObject.FlaggedTokens[0].Suggestions[0]?.Correction;
await turnContext.SendActivityAsync("Did you mean: " + bestResult + "?");
return;
}
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken).ConfigureAwait(false);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case GreetingIntent:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case NoneIntent:
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded.Any())
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response).ConfigureAwait(false);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
var activity = turnContext.Activity;
// Create a dialog context
var dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
var luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
var topScoringIntent = luisResults?.GetTopScoringIntent();
var topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateGreetingState(luisResults, dc.Context);
// Handle conversation interrupts first.
var interrupted = await IsTurnInterruptedAsync(dc, topIntent);
if (interrupted)
{
// Bypass the dialog.
// Save state before the next turn.
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
return;
}
// Continue the current dialog
var dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case SayHello:
await dc.BeginDialogAsync(nameof(GreetingDialog));
break;
case TellAuthorsBooks:
var ent = luisResults.Entities["AuthorName"];
if (ent != null)
{
var author = ent.First().ToString();
var message = string.Empty;
var solutions = _prologEngine.GetAllSolutions(null, $"book(B, \"{author}\", _, _).");
if (solutions.Success)
{
message += $"{author} wrote such books: ";
foreach (Solution s in solutions.NextSolution)
{
foreach (Variable v in s.NextVariable)
{
if (v.Type != "namedvar")
{
message += $"\n {v.Value}";
}
}
}
}
else
{
message = "This author is missing in the database. Please, connect bot to Internet.";
}
await turnContext.SendActivityAsync(message);
}
else
{
await turnContext.SendActivityAsync("This author is missing in the database. Please, connect bot to Internet.");
}
break;
case AskToRecommendBook:
luisResults.Entities.TryGetValue("Genre", out var genre);
await turnContext.SendActivityAsync(_prologBookService.RecommendBook(genre?.First().First().ToString()));
break;
case RecommendBookByPreference:
luisResults.Entities.TryGetValue("UserName", out var username);
await turnContext.SendActivityAsync(_prologBookService.RecommendBookByPreference(username.First().ToString()));
break;
case TellAuthorOfSpecificBook:
var bookname = luisResults.Entities["BookName"].First().ToString().Trim('\'');
var authorname = _prologBookService.GetAuthorOfTheBookName(bookname);
var response = string.IsNullOrEmpty(authorname)
? "There is no such book in the database. \n Please, connect bot to the Internet."
: $"{authorname} wrote book {bookname}";
await turnContext.SendActivityAsync(response);
break;
case TellGenresOfBooks:
var bookGenresMessage = "These are different book genres: ";
var genres = _prologEngine.GetAllSolutions(null, $"genre(G).");
if (genres.Success)
{
foreach (Solution s in genres.NextSolution)
{
foreach (Variable v in s.NextVariable)
{
if (v.Type != "namedvar")
{
bookGenresMessage += $"\n {v.Value}";
}
}
}
}
else
{
bookGenresMessage = "Sorry, I can't tell you about book genres. Please, connect bot to Internet.";
}
await turnContext.SendActivityAsync(bookGenresMessage);
break;
case TellIfBookIsWorthReading:
var book = luisResults.Entities["BookName"].First().ToString().Replace('\'', '\"');
var bookIsWorthReading = _prologEngine.GetFirstSolution($"bookIsWorthReading({book}).");
if (bookIsWorthReading.Solved)
{
await turnContext.SendActivityAsync("I definitely recommend you this book! It's rate is pretty high.");
}
else
{
await turnContext.SendActivityAsync("I do not recommend you this book. Based on it's rate I can say that many people were disappointed.");
}
break;
case TellIfAuthorIsVeryFamous:
var name = luisResults.Entities["AuthorName"].First().ToString();
var authorIsFamous = _prologEngine.GetFirstSolution($"authorIsWorldFamous({name}).");
if (authorIsFamous.Solved)
{
await turnContext.SendActivityAsync($"{name} is very famous all around the world. You should definitely get acquinted with his/her books.");
}
else
{
await turnContext.SendActivityAsync($"No, {name} is not very famous.");
}
break;
case None:
default:
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
// Iterate over all new members added to the conversation.
foreach (var member in activity.MembersAdded)
{
// Greet anyone that was not the target (recipient) of this message.
// To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if (member.Id != activity.Recipient.Id)
{
var welcomeCard = CreateAdaptiveCardAttachment();
var response = CreateResponse(activity, welcomeCard);
await dc.Context.SendActivityAsync(response);
}
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}
/// <summary>
/// Run every turn of the conversation. Handles orchestration of messages.
/// </summary>
/// <param name="turnContext">Bot Turn Context.</param>
/// <param name="cancellationToken">Task CancellationToken.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken)
{
Activity activity = turnContext.Activity;
// Create a dialog context
DialogContext dc = await Dialogs.CreateContextAsync(turnContext);
if (activity.Type == ActivityTypes.Message)
{
// Perform a call to LUIS to retrieve results for the current activity message.
RecognizerResult luisResults = await _services.LuisServices[LuisConfiguration].RecognizeAsync(dc.Context, cancellationToken).ConfigureAwait(false);
// If any entities were updated, treat as interruption.
// For example, "no my name is tony" will manifest as an update of the name to be "tony".
(string intent, double score)? topScoringIntent = luisResults?.GetTopScoringIntent();
string topIntent = topScoringIntent.Value.intent;
// update greeting state with any entities captured
await UpdateBlockchainState(luisResults, dc.Context);
// Continue the current dialog
DialogTurnResult dialogResult = await dc.ContinueDialogAsync();
// if no one has responded,
if (!dc.Context.Responded)
{
// examine results from active dialog
switch (dialogResult.Status)
{
case DialogTurnStatus.Empty:
switch (topIntent)
{
case MarketplaceIntent:
await dc.BeginDialogAsync(nameof(BlockchainDialog));
break;
default:
// Help or no intent identified, either way, let's provide some help.
// to the user
await dc.Context.SendActivityAsync("I didn't understand what you just said to me.");
break;
}
break;
case DialogTurnStatus.Waiting:
// The active dialog is waiting for a response from the user, so do nothing.
break;
case DialogTurnStatus.Complete:
await dc.EndDialogAsync();
break;
default:
await dc.CancelAllDialogsAsync();
break;
}
}
}
await _conversationState.SaveChangesAsync(turnContext);
await _userState.SaveChangesAsync(turnContext);
}