public async Task <DialogTurnResult> ShowTasks(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
state.ListType = state.ListType ?? ToDoStrings.ToDo;
state.LastListType = state.ListType;
var service = await InitListTypeIds(sc);
var topIntent = state.LuisResult?.TopIntent().intent;
if (topIntent == ToDoLU.Intent.ShowToDo || state.GoBackToStart)
{
state.AllTasks = await service.GetTasksAsync(state.ListType);
}
var allTasksCount = state.AllTasks.Count;
var currentTaskIndex = state.ShowTaskPageIndex * state.PageSize;
state.Tasks = state.AllTasks.GetRange(currentTaskIndex, Math.Min(state.PageSize, allTasksCount - currentTaskIndex));
var generalTopIntent = state.GeneralLuisResult?.TopIntent().intent;
if (state.Tasks.Count <= 0)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(ShowToDoResponses.NoTasksMessage, new StringDictionary()
{
{ "listType", state.ListType }
}));
return(await sc.EndDialogAsync(true));
}
else
{
var cardReply = sc.Context.Activity.CreateReply();
if (topIntent == ToDoLU.Intent.ShowToDo || state.GoBackToStart)
{
var toDoListCard = ToAdaptiveCardForShowToDos(
state.Tasks,
state.AllTasks.Count,
state.ListType);
await sc.Context.SendActivityAsync(toDoListCard);
if (allTasksCount <= state.Tasks.Count)
{
var response = ResponseManager.GetResponse(ShowToDoResponses.AskAddOrCompleteTaskMessage);
await sc.Context.SendActivityAsync(response);
}
}
else if (topIntent == ToDoLU.Intent.ShowNextPage || generalTopIntent == General.Intent.ShowNext)
{
if (state.IsLastPage)
{
state.IsLastPage = false;
return(await sc.ReplaceDialogAsync(Action.CollectGoBackToStartConfirmation));
}
else
{
var toDoListCard = ToAdaptiveCardForReadMore(
state.Tasks,
state.AllTasks.Count,
state.ListType);
await sc.Context.SendActivityAsync(toDoListCard);
if ((state.ShowTaskPageIndex + 1) * state.PageSize >= state.AllTasks.Count)
{
return(await sc.ReplaceDialogAsync(Action.CollectGoBackToStartConfirmation));
}
}
}
else if (topIntent == ToDoLU.Intent.ShowPreviousPage || generalTopIntent == General.Intent.ShowPrevious)
{
if (state.IsFirstPage)
{
state.IsFirstPage = false;
return(await sc.ReplaceDialogAsync(Action.CollectRepeatFirstPageConfirmation));
}
else
{
var toDoListCard = ToAdaptiveCardForPreviousPage(
state.Tasks,
state.AllTasks.Count,
state.ShowTaskPageIndex == 0,
state.ListType);
await sc.Context.SendActivityAsync(toDoListCard);
}
}
if ((topIntent == ToDoLU.Intent.ShowToDo || state.GoBackToStart) && allTasksCount > state.Tasks.Count)
{
state.GoBackToStart = false;
return(await sc.NextAsync());
}
else
{
state.GoBackToStart = false;
return(await sc.EndDialogAsync(true));
}
}
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
// This step routes the user to different dialogs
// In this case, there's only one other dialog, so it is more simple,
// but in more complex scenarios you can go off to other dialogs in a similar
public async Task <DialogTurnResult> MainMenuAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// Check if we are currently processing a user's search
var state = await _accessors.PictureState.GetAsync(stepContext.Context);
// If Regex picks up on anything, store it
var recognizedIntents = stepContext.Context.TurnState.Get <IRecognizedIntents>();
// Based on the recognized intent, direct the conversation
switch (recognizedIntents.TopIntent?.Name)
{
case "search":
// switch to the search dialog
return(await stepContext.BeginDialogAsync("searchDialog", null, cancellationToken));
case "share":
// respond that you're sharing the photo
await MainResponses.ReplyWithShareConfirmation(stepContext.Context);
return(await stepContext.EndDialogAsync());
case "order":
// respond that you're ordering
await MainResponses.ReplyWithOrderConfirmation(stepContext.Context);
return(await stepContext.EndDialogAsync());
case "help":
// show help
await MainResponses.ReplyWithHelp(stepContext.Context);
return(await stepContext.EndDialogAsync());
default:
{
// Call LUIS recognizer
var result = await _recognizer.RecognizeAsync(stepContext.Context, cancellationToken);
// Get the top intent from the results
var topIntent = result?.GetTopScoringIntent();
// Based on the intent, switch the conversation, similar concept as with Regex above
switch ((topIntent != null) ? topIntent.Value.intent : null)
{
case null:
// Add app logic when there is no result.
await MainResponses.ReplyWithConfused(stepContext.Context);
break;
case "None":
await MainResponses.ReplyWithConfused(stepContext.Context);
// with each statement, we're adding the LuisScore, purely to test, so we know whether LUIS was called or not
await MainResponses.ReplyWithLuisScore(stepContext.Context, topIntent.Value.intent, topIntent.Value.score);
break;
case "Greeting":
await MainResponses.ReplyWithGreeting(stepContext.Context);
await MainResponses.ReplyWithHelp(stepContext.Context);
await MainResponses.ReplyWithLuisScore(stepContext.Context, topIntent.Value.intent, topIntent.Value.score);
break;
case "OrderPic":
await MainResponses.ReplyWithOrderConfirmation(stepContext.Context);
await MainResponses.ReplyWithLuisScore(stepContext.Context, topIntent.Value.intent, topIntent.Value.score);
break;
case "SharePic":
await MainResponses.ReplyWithShareConfirmation(stepContext.Context);
await MainResponses.ReplyWithLuisScore(stepContext.Context, topIntent.Value.intent, topIntent.Value.score);
break;
default:
await MainResponses.ReplyWithConfused(stepContext.Context);
break;
}
return(await stepContext.EndDialogAsync());
}
}
}
public async Task <DialogTurnResult> ShowNextEvent(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var askParameter = new AskParameterModel(state.AskParameterContent);
if (string.IsNullOrEmpty(state.APIToken))
{
return(await sc.EndDialogAsync(true));
}
var calendarService = ServiceManager.InitCalendarService(state.APIToken, state.EventSource);
var eventList = await calendarService.GetUpcomingEvents();
var nextEventList = new List <EventModel>();
foreach (var item in eventList)
{
if (item.IsCancelled != true && (nextEventList.Count == 0 || nextEventList[0].StartTime == item.StartTime))
{
nextEventList.Add(item);
}
}
if (nextEventList.Count == 0)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowNoMeetingMessage));
}
else
{
if (nextEventList.Count == 1)
{
// if user asked for specific details
if (askParameter.NeedDetail)
{
var tokens = new StringDictionary()
{
{ "EventName", nextEventList[0].Title },
{ "EventStartTime", TimeConverter.ConvertUtcToUserTime(nextEventList[0].StartTime, state.GetUserTimeZone()).ToString("h:mm tt") },
{ "EventEndTime", TimeConverter.ConvertUtcToUserTime(nextEventList[0].EndTime, state.GetUserTimeZone()).ToString("h:mm tt") },
{ "EventDuration", nextEventList[0].ToDurationString() },
{ "EventLocation", nextEventList[0].Location },
};
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.BeforeShowEventDetails, tokens));
if (askParameter.NeedTime)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ReadTime, tokens));
}
if (askParameter.NeedDuration)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ReadDuration, tokens));
}
if (askParameter.NeedLocation)
{
// for some event there might be no localtion.
if (string.IsNullOrEmpty(tokens["EventLocation"]))
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ReadNoLocation));
}
else
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ReadLocation, tokens));
}
}
}
var speakParams = new StringDictionary()
{
{ "EventName", nextEventList[0].Title },
{ "PeopleCount", nextEventList[0].Attendees.Count.ToString() },
};
speakParams.Add("EventTime", SpeakHelper.ToSpeechMeetingDateTime(TimeConverter.ConvertUtcToUserTime(nextEventList[0].StartTime, state.GetUserTimeZone()), nextEventList[0].IsAllDay == true));
if (string.IsNullOrEmpty(nextEventList[0].Location))
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowNextMeetingNoLocationMessage, speakParams));
}
else
{
speakParams.Add("Location", nextEventList[0].Location);
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowNextMeetingMessage, speakParams));
}
}
else
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowMultipleNextMeetingMessage));
}
await ShowMeetingList(sc, nextEventList, true);
}
state.Clear();
return(await sc.EndDialogAsync(true));
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
/// <summary>
/// Prompt for Restaurant to book.
/// </summary>
/// <param name="sc">Waterfall Step Context.</param>
/// <param name="cancellationToken">Cancellation Token.</param>
/// <returns>Dialog Turn Result.</returns>
private async Task <DialogTurnResult> AskForRestaurant(WaterfallStepContext sc, CancellationToken cancellationToken)
{
var state = await ConversationStateAccessor.GetAsync(sc.Context);
var reservation = state.Booking;
// Reset the dialog if the user hasn't confirmed the reservation.
if (!reservation.Confirmed)
{
state.Booking = CreateNewReservationInfo();
return(await sc.EndDialogAsync());
}
// Prompt for restaurant
var restaurants = SeedReservationSampleData.GetListOfRestaurants(reservation.Category, "London", _urlResolver);
state.Restaurants = restaurants;
var restaurantOptionsForSpeak = new StringBuilder();
for (var i = 0; i < restaurants.Count; i++)
{
restaurantOptionsForSpeak.Append(restaurants[i].Name);
restaurantOptionsForSpeak.Append(i == restaurants.Count - 2 ? $" {BotStrings.Or} " : ", ");
}
var tokens = new StringDictionary
{
{ "RestaurantCount", restaurants.Count.ToString() },
{ "ServerUrl", _urlResolver.ServerUrl },
{ "RestaurantList", restaurantOptionsForSpeak.ToString() }
};
var cards = new List <Card>();
var options = new PromptOptions()
{
Choices = new List <Choice>(),
};
foreach (var restaurant in restaurants)
{
cards.Add(new Card(
"RestaurantChoiceCard",
new RestaurantChoiceCardData
{
ImageUrl = restaurant.PictureUrl,
ImageSize = AdaptiveImageSize.Stretch,
ImageAlign = AdaptiveHorizontalAlignment.Stretch,
Name = restaurant.Name,
Title = restaurant.Name,
Location = restaurant.Location,
SelectedItemData = restaurant.Name
}));
options.Choices.Add(new Choice(restaurant.Name));
}
var replyMessage = ResponseManager.GetCardResponse(RestaurantBookingSharedResponses.BookRestaurantRestaurantSelectionPrompt, cards, tokens);
return(await sc.PromptAsync(Actions.RestaurantPrompt, new PromptOptions { Prompt = replyMessage, Choices = options.Choices }, cancellationToken));
}
protected async Task <DialogTurnResult> MarkTaskCompleted(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
state.LastListType = state.ListType;
var service = await InitListTypeIds(sc);
string taskTopicToBeMarked = null;
if (state.MarkOrDeleteAllTasksFlag)
{
await service.MarkTasksCompletedAsync(state.ListType, state.AllTasks);
state.AllTasks.ForEach(task => task.IsCompleted = true);
state.ShowTaskPageIndex = 0;
}
else
{
taskTopicToBeMarked = state.AllTasks[state.TaskIndexes[0]].Topic;
var tasksToBeMarked = new List <TaskItem>();
state.TaskIndexes.ForEach(i => tasksToBeMarked.Add(state.AllTasks[i]));
await service.MarkTasksCompletedAsync(state.ListType, tasksToBeMarked);
state.TaskIndexes.ForEach(i => state.AllTasks[i].IsCompleted = true);
state.ShowTaskPageIndex = state.TaskIndexes[0] / state.PageSize;
}
var allTasksCount = state.AllTasks.Count;
var currentTaskIndex = state.ShowTaskPageIndex * state.PageSize;
state.Tasks = state.AllTasks.GetRange(currentTaskIndex, Math.Min(state.PageSize, allTasksCount - currentTaskIndex));
var markToDoAttachment = ToAdaptiveCardForTaskCompletedFlow(
state.Tasks,
state.AllTasks.Count,
taskTopicToBeMarked,
state.ListType,
state.MarkOrDeleteAllTasksFlag);
var cardReply = sc.Context.Activity.CreateReply();
cardReply.Attachments.Add(markToDoAttachment);
var uncompletedTaskIndex = state.AllTasks.FindIndex(t => t.IsCompleted == false);
if (state.MarkOrDeleteAllTasksFlag || uncompletedTaskIndex < 0)
{
cardReply.InputHint = InputHints.AcceptingInput;
await sc.Context.SendActivityAsync(cardReply);
return(await sc.EndDialogAsync(true));
}
else
{
cardReply.InputHint = InputHints.IgnoringInput;
await sc.Context.SendActivityAsync(cardReply);
return(await sc.NextAsync());
}
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
// Send a Rich Card response to the user based on their choice.
// This method is only called when a valid prompt response is parsed from the user's response to the ChoicePrompt.
private async Task <DialogTurnResult> ShowCardStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
_logger.LogInformation("MainDialog.ShowCardStepAsync");
// Reply to the activity we received with an activity.
var reply = stepContext.Context.Activity.CreateReply();
// Cards are sent as Attachments in the Bot Framework.
// So we need to create a list of attachments on the activity.
reply.Attachments = new List <Attachment>();
// Decide which type of card(s) we are going to show the user
switch (((FoundChoice)stepContext.Result).Value)
{
case "Markdown":
// Display an AnimationCard.
reply.Text = "*text downgrade from markdown bold text*";
reply.TextFormat = TextFormatTypes.Markdown;
break;
case "Animation Card":
// Display an AnimationCard.
reply.Attachments.Add(Cards.GetAnimationCard().ToAttachment());
break;
case "Audio Card":
// Display an AudioCard
reply.Attachments.Add(Cards.GetAudioCard().ToAttachment());
break;
case "Hero Card":
// Display a HeroCard.
reply.Attachments.Add(Cards.GetHeroCard().ToAttachment());
break;
case "Receipt Card":
// Display a ReceiptCard.
reply.Attachments.Add(Cards.GetReceiptCard().ToAttachment());
break;
case "Signin Card":
// Display a SignInCard.
reply.Attachments.Add(Cards.GetSigninCard().ToAttachment());
break;
case "Thumbnail Card":
// Display a ThumbnailCard.
reply.Attachments.Add(Cards.GetThumbnailCard().ToAttachment());
break;
case "Video Card":
// Display a VideoCard
reply.Attachments.Add(Cards.GetVideoCard().ToAttachment());
break;
case "Adaptive Card":
// Display a VideoCard
reply.Text = "adaptive card";
reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment());
break;
case "Carousel":
// Display a VideoCard
reply.Text = "WeChat not support carousel natively, will downgrade to list.";
reply.Attachments.Add(Cards.GetAnimationCard().ToAttachment());
reply.Attachments.Add(Cards.GetThumbnailCard().ToAttachment());
reply.Attachments.Add(Cards.GetAudioCard().ToAttachment());
reply.Attachments.Add(Cards.GetSigninCard().ToAttachment());
reply.Attachments.Add(Cards.GetVideoCard().ToAttachment());
reply.Attachments.Add(Cards.CreateAdaptiveCardAttachment());
break;
case "SuggestedActions":
// Display a VideoCard
reply.Text = "Suggest Actions";
reply.SuggestedActions = new SuggestedActions()
{
Actions = new List <CardAction>()
{
new CardAction()
{
Title = ActionTypes.MessageBack, Type = ActionTypes.MessageBack, Value = "messageBack"
},
new CardAction()
{
Title = ActionTypes.ImBack, Type = ActionTypes.ImBack, Value = "imBack"
},
},
};
break;
case "Images":
// Display a VideoCard
reply.Text = "Images";
reply.Attachments = new List <Attachment>()
{
new Attachment()
{
ContentType = "image/png",
ContentUrl = "https://docs.microsoft.com/en-us/bot-framework/media/how-it-works/architecture-resize.png",
},
new Attachment()
{
ContentType = "image/jpeg",
ContentUrl = "https://docs.microsoft.com/en-us/bot-framework/media/how-it-works/architecture-resize.png",
},
};
break;
case "Videos":
// Display a VideoCard
reply.Text = "Videos";
reply.Attachments = new List <Attachment>()
{
new Attachment()
{
ContentType = "video/mp4",
ContentUrl = "http://techslides.com/demos/sample-videos/small.mp4",
},
new Attachment()
{
ContentType = "video/mp4",
ContentUrl = "http://techslides.com/demos/sample-videos/small.mp4",
},
};
break;
case "MessageMenu":
// Display Message menu
string[] paths = { ".", "Resources", "messageMenu.json" };
var menuJson = File.ReadAllText(Path.Combine(paths));
reply.ChannelData = new
{
touser = stepContext.Context.Activity.From.Id,
msgtype = ResponseMessageTypes.MessageMenu,
msgmenu = JObject.Parse(menuJson),
};
break;
default:
// Give the user instructions about what to do next
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Type anything to show the choice list again."), cancellationToken);
return(await stepContext.EndDialogAsync());
}
// Send the card(s) to the user as an attachment to the activity
await stepContext.Context.SendActivityAsync(reply, cancellationToken);
// Give the user instructions about what to do next
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Type anything to show the choice list again."), cancellationToken);
return(await stepContext.EndDialogAsync());
}
private async Task <DialogTurnResult> IntroStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
TelemetryClient.TrackTrace("Main dialog started", Severity.Information, null);
if (string.IsNullOrEmpty(Configuration["DailyChallengeTableConnectionString"]))
{
TelemetryClient.TrackTrace("Connection String not defined", Severity.Error, null);
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: Storage Connection String is not configured. To continue, add 'DailyChallengeTableConnectionString' to the appsettings.json file."), cancellationToken);
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
else
{
IMessageActivity reply = null;
TelemetryClient.TrackTrace("Get Daily Challenge and Team Info", Severity.Information, null);
DailyChallenge dailyChallenge = await tableService.GetDailyChallenge();
DailyChallengeTeam team = await tableService.getDailyChallengeTeamInfo();
TelemetryClient.TrackTrace("Check whether today's challenge exists", Severity.Information, null);
if (dailyChallenge.photoUrl == null)
{
TelemetryClient.TrackTrace("No Daily Challenge so check details", Severity.Information, null);
var activity = stepContext.Context.Activity;
if (team.ChannelData == null)
{
team.ChannelData = activity.GetChannelData <TeamsChannelData>();
}
var teamsChannelData = team.ChannelData;
var channelId = teamsChannelData.Channel.Id;
var tenantId = teamsChannelData.Tenant.Id;
string myBotId = activity.Recipient.Id;
string teamId = teamsChannelData.Team.Id;
string teamName = teamsChannelData.Team.Name;
await this.tableService.SaveDailyChallengeTeamInfo(new DailyChallengeTeam()
{
ServiceUrl = activity.ServiceUrl,
TeamId = teamId,
TeamName = teamName,
TenantId = tenantId,
InstallerName = "Automatic",
BotId = myBotId,
ChannelId = channelId,
ChannelData = teamsChannelData
});
reply = MessageFactory.Attachment(new List <Attachment>());
Attachment attachment = null;
DailyChallengeInfo info = await GetInfo(stepContext);
if (info.currentSource == ImageSource.Google)
{
TelemetryClient.TrackTrace("Current source is Google so get an image", Severity.Information, null);
attachment = await GetGoogleImageChoiceAttachment();
TelemetryClient.TrackTrace("Loaded Google image", Severity.Information, null);
}
else
{
TelemetryClient.TrackTrace("Current source is Bing so get the latest image", Severity.Information, null);
int imageIndex = info.currentImageIndex;
attachment = await GetBingImageChoiceAttachment(imageIndex);
TelemetryClient.TrackTrace("Loaded Bing image", Severity.Information, null);
}
reply.Attachments.Add(attachment);
TelemetryClient.TrackTrace("Sending image reply", Severity.Information, null);
return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = (Activity)reply }, cancellationToken));
}
else
{
if (!dailyChallenge.resultSet)
{
// Pass on the check results message from the proactive controller if set
PromptOptions options = null;
if (stepContext != null && stepContext.Options != null)
{
options = (PromptOptions)stepContext.Options;
}
return(await stepContext.ReplaceDialogAsync(nameof(ChallengeGuesserDialog), options, cancellationToken));
}
else
{
IMessageActivity winningReply = MessageFactory.Attachment(new List <Attachment>());
winningReply.Attachments.Add(AttachmentHelper.ResultCardAttachment(dailyChallenge.winnerName, dailyChallenge.photoUrl, dailyChallenge.winnerGuess, dailyChallenge.distanceToEntry.ToString("#.##"), dailyChallenge.extractedLocation, dailyChallenge.text));
await stepContext.Context.SendActivityAsync(winningReply);
return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken));
}
}
}
}
private async Task <DialogTurnResult> SendChange(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
var state = await Accessor.GetAsync(sc.Context);
var settingChangeConfirmed = false;
// If we skip the ConfirmPrompt due to no confirmation needed then Result will be NULL
if (sc.Result == null)
{
settingChangeConfirmed = true;
}
else
{
settingChangeConfirmed = (bool)sc.Result;
}
if (settingChangeConfirmed)
{
var change = state.Changes[0];
// If the change involves an amount then we add this to the change event
if (change.Amount != null)
{
var promptReplacements = new StringDictionary
{
{ "settingName", change.SettingName },
{ "amount", change.Amount.Amount.ToString() },
{ "unit", UnitToString(change.Amount.Unit) },
};
if (change.IsRelativeAmount)
{
if (change.Amount.Amount < 0)
{
promptReplacements["increasingDecreasing"] = VehicleSettingsStrings.DECREASING;
promptReplacements["amount"] = (-change.Amount.Amount).ToString();
}
else
{
promptReplacements["increasingDecreasing"] = VehicleSettingsStrings.INCREASING;
}
// Send an event to the device along with the text confirmation
await SendActionToDevice(sc, change, promptReplacements);
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(
VehicleSettingsResponses.VehicleSettingsChangingRelativeAmount, ResponseBuilder));
}
else
{
// Send an event to the device along with the text confirmation
await SendActionToDevice(sc, change, promptReplacements);
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(
VehicleSettingsResponses.VehicleSettingsChangingAmount, ResponseBuilder, promptReplacements));
}
}
else
{
// Binary event (on/off)
BotResponse promptTemplate;
var promptReplacements = new StringDictionary {
{ "settingName", change.SettingName }
};
if (SettingValueToSpeakableIngForm.TryGetValue(change.Value.ToLowerInvariant(), out var valueIngForm))
{
promptTemplate = VehicleSettingsResponses.VehicleSettingsChangingValueKnown;
promptReplacements["valueIngForm"] = valueIngForm;
}
else
{
promptTemplate = VehicleSettingsResponses.VehicleSettingsChangingValue;
promptReplacements["value"] = change.Value;
}
// Send an event to the device along with the text confirmation
await SendActionToDevice(sc, change, promptReplacements);
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(promptTemplate, ResponseBuilder, promptReplacements));
}
}
else
{
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsSettingChangeConfirmationDenied));
}
return(await sc.EndDialogAsync());
}
protected async Task <DialogTurnResult> ReadEmail(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
var skillOptions = (EmailSkillDialogOptions)sc.Options;
sc.Context.Activity.Properties.TryGetValue("OriginText", out var content);
var userInput = content != null?content.ToString() : sc.Context.Activity.Text;
var luisResult = state.LuisResult;
var topIntent = luisResult?.TopIntent().intent;
var generalLuisResult = state.GeneralLuisResult;
var generalTopIntent = generalLuisResult?.TopIntent().intent;
if (topIntent == null)
{
return(await sc.EndDialogAsync(true));
}
await DigestFocusEmailAsync(sc);
var message = state.Message.FirstOrDefault();
if (message == null)
{
state.Message.Add(state.MessageList[0]);
message = state.Message.FirstOrDefault();
}
var promptRecognizerResult = ConfirmRecognizerHelper.ConfirmYesOrNo(userInput, sc.Context.Activity.Locale);
if ((topIntent == EmailLuis.Intent.None ||
topIntent == EmailLuis.Intent.SearchMessages ||
(topIntent == EmailLuis.Intent.ReadAloud && !IsReadMoreIntent(generalTopIntent, sc.Context.Activity.Text)) ||
(promptRecognizerResult.Succeeded && promptRecognizerResult.Value == true)) &&
message != null)
{
var senderIcon = await GetUserPhotoUrlAsync(sc.Context, message.Sender.EmailAddress);
var emailCard = new EmailCardData
{
Subject = message.Subject,
Sender = message.Sender.EmailAddress.Name,
EmailContent = message.BodyPreview,
EmailLink = message.WebLink,
ReceivedDateTime = message?.ReceivedDateTime == null
? CommonStrings.NotAvailable
: message.ReceivedDateTime.Value.UtcDateTime.ToDetailRelativeString(state.GetUserTimeZone()),
Speak = SpeakHelper.ToSpeechEmailDetailOverallString(message, state.GetUserTimeZone()),
SenderIcon = senderIcon
};
emailCard = await ProcessRecipientPhotoUrl(sc.Context, emailCard, message.ToRecipients);
var tokens = new StringDictionary()
{
{ "EmailDetails", SpeakHelper.ToSpeechEmailDetailString(message, state.GetUserTimeZone()) },
{ "EmailDetailsWithContent", SpeakHelper.ToSpeechEmailDetailString(message, state.GetUserTimeZone(), true) },
};
var recipientCard = message.ToRecipients.Count() > 5 ? GetDivergedCardName(sc.Context, "DetailCard_RecipientMoreThanFive") : GetDivergedCardName(sc.Context, "DetailCard_RecipientLessThanFive");
var replyMessage = ResponseManager.GetCardResponse(
ShowEmailResponses.ReadOutMessage,
new Card("EmailDetailCard", emailCard),
tokens,
"items",
new List <Card>().Append(new Card(recipientCard, emailCard)));
// Set email as read.
var service = ServiceManager.InitMailService(state.Token, state.GetUserTimeZone(), state.MailSourceType);
await service.MarkMessageAsReadAsync(message.Id);
await sc.Context.SendActivityAsync(replyMessage);
}
return(await sc.NextAsync());
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
/// <summary>
/// Once we have a setting we need to process the corresponding value.
/// </summary>
/// <param name="sc">Step Context.</param>
/// <returns>Dialog Turn Result.</returns>
private async Task <DialogTurnResult> ProcessVehicleSettingsChange(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
var state = await Accessor.GetAsync(sc.Context);
if (state.Changes.Any())
{
var settingValues = state.GetUniqueSettingValues();
if (!settingValues.Any())
{
// This shouldn't happen because the SettingFilter would just add all possible values to let the user select from them.
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsOutOfDomain));
return(await sc.EndDialogAsync());
}
else
{
// We have found multiple settings which we need to prompt the user to resolve
if (settingValues.Count() > 1)
{
string settingName = state.Changes.First().SettingName;
var setting = this.settingList.FindSetting(settingName);
// If a category image filename is provided we'll use it otherwise fall back to the generic car one
string imageName = setting.CategoryImageFileName ?? FallbackSettingImageFileName;
// If we have more than one setting name matching prompt the user to choose
var options = new PromptOptions()
{
Choices = new List <Choice>(),
};
for (var i = 0; i < settingValues.Count; ++i)
{
var item = settingValues[i];
var choice = new Choice()
{
Value = item,
Synonyms = new List <string> {
(i + 1).ToString(), item
},
};
options.Choices.Add(choice);
}
BotResponse promptTemplate = VehicleSettingsResponses.VehicleSettingsSettingValueSelectionPre;
var promptReplacements = new StringDictionary {
{ "settingName", settingName }
};
options.Prompt = sc.Context.Activity.CreateReply(promptTemplate, ResponseBuilder, promptReplacements);
var card = new ThumbnailCard
{
Title = options.Prompt.Text,
Text = VehicleSettingsResponses.WhichSettingValue.Reply.Text,
Images = new List <CardImage> {
new CardImage(GetSettingCardImageUri(imageName))
},
Buttons = options.Choices.Select(choice =>
new CardAction(ActionTypes.ImBack, choice.Value, value: choice.Value)).ToList(),
};
options.Prompt.Attachments.Add(card.ToAttachment());
// Default Text property is clumsy for speech
var speakOptions = options.Choices.Select(choice => choice.Value.ToString()).ToList();
options.Prompt.Speak = $"{options.Prompt.Text} {string.Join(",", speakOptions)}";
return(await sc.PromptAsync(Actions.SettingValueSelectionPrompt, options));
}
else
{
// We only have one setting value so proceed to next step
return(await sc.NextAsync());
}
}
}
else
{
// No setting value was understood
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsOutOfDomain));
return(await sc.EndDialogAsync());
}
}
/// <summary>
/// Process the change that we are about to perform. If required the user is prompted for confirmation.
/// </summary>
/// <param name="sc">Step Context.</param>
/// <param name="cancellationToken">Cancellation Token.</param>
/// <returns>Dialog Turn Result.</returns>
private async Task <DialogTurnResult> ProcessChange(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
var state = await Accessor.GetAsync(sc.Context);
// Perform the request change
if (state.Changes.Any())
{
var change = state.Changes[0];
if (change.OperationStatus == SettingOperationStatus.TO_DO)
{
// TODO - Validation of change would go here, for now we just apply the change
var availableSetting = this.settingList.FindSetting(change.SettingName);
var availableSettingValue = this.settingList.FindSettingValue(availableSetting, change.Value);
// Check confirmation first.
if (availableSettingValue != null && availableSettingValue.RequiresConfirmation)
{
var promptTemplate = VehicleSettingsResponses.VehicleSettingsSettingChangeConfirmation;
var promptReplacements = new StringDictionary
{
{ "settingName", change.SettingName },
{ "value", change.Value },
};
if (availableSetting != null && !string.IsNullOrEmpty(availableSetting.Category))
{
promptTemplate = VehicleSettingsResponses.VehicleSettingsSettingChangeConfirmationWithCategory;
promptReplacements.Add("category", availableSetting.Category);
if (WordRequiresAn.Match(promptReplacements["category"]).Success)
{
promptReplacements.Add("aOrAnBeforeCategory", "an");
}
else
{
promptReplacements.Add("aOrAnBeforeCategory", "a");
}
}
// TODO - Explore moving to ConfirmPrompt following usability testing
var prompt = sc.Context.Activity.CreateReply(promptTemplate, ResponseBuilder, promptReplacements);
return(await sc.PromptAsync(Actions.SettingConfirmationPrompt, new PromptOptions { Prompt = prompt }));
}
else
{
// No confirmation required so we skip to sending the change
return(await sc.NextAsync());
}
}
else
{
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsSettingChangeUnsupported));
return(await sc.EndDialogAsync());
}
}
else
{
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsSettingChangeUnsupported));
return(await sc.EndDialogAsync());
}
}
/// <summary>
/// Top level processing, is the user trying to check or change a setting?.
/// </summary>
/// <param name="sc">Step Context.</param>
/// <param name="cancellationToken">Cancellation Token.</param>
/// <returns>Dialog Turn Result.</returns>
public async Task <DialogTurnResult> ProcessSetting(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
var state = await Accessor.GetAsync(sc.Context, () => new AutomotiveSkillState());
// Ensure we don't have state from a previous instantiation
state.Changes.Clear();
state.Entities.Clear();
var luisResult = state.VehicleSettingsLuisResult;
var topIntent = luisResult?.TopIntent().intent;
switch (topIntent.Value)
{
case Luis.VehicleSettings.Intent.VEHICLE_SETTINGS_CHANGE:
case Luis.VehicleSettings.Intent.VEHICLE_SETTINGS_DECLARATIVE:
// Process the LUIS result and add entities to the State accessors for ease of access
if (luisResult.Entities.AMOUNT != null)
{
state.Entities.Add(nameof(luisResult.Entities.AMOUNT), luisResult.Entities.AMOUNT);
}
if (luisResult.Entities.INDEX != null)
{
state.Entities.Add(nameof(luisResult.Entities.INDEX), luisResult.Entities.INDEX);
}
if (luisResult.Entities.SETTING != null)
{
state.Entities.Add(nameof(luisResult.Entities.SETTING), luisResult.Entities.SETTING);
}
if (luisResult.Entities.TYPE != null)
{
state.Entities.Add(nameof(luisResult.Entities.TYPE), luisResult.Entities.TYPE);
}
if (luisResult.Entities.UNIT != null)
{
state.Entities.Add(nameof(luisResult.Entities.UNIT), luisResult.Entities.UNIT);
}
if (luisResult.Entities.VALUE != null)
{
state.Entities.Add(nameof(luisResult.Entities.VALUE), luisResult.Entities.VALUE);
}
// Perform post-processing on the entities, if it's declarative we indicate for special processing (opposite of the condition they've expressed)
settingFilter.PostProcessSettingName(state, topIntent.Value == Luis.VehicleSettings.Intent.VEHICLE_SETTINGS_DECLARATIVE ? true : false);
// Perform content logic and remove entities that don't make sense
settingFilter.ApplyContentLogic(state);
var settingNames = state.GetUniqueSettingNames();
if (!settingNames.Any())
{
// missing setting name
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsMissingSettingName));
return(await sc.EndDialogAsync());
}
else if (settingNames.Count() > 1)
{
// If we have more than one setting name matching prompt the user to choose
var options = new PromptOptions()
{
Choices = new List <Choice>(),
};
for (var i = 0; i < settingNames.Count; ++i)
{
var item = settingNames[i];
var choice = new Choice()
{
Value = item,
Synonyms = new List <string> {
(i + 1).ToString(), item
},
};
options.Choices.Add(choice);
}
BotResponse settingNamePrompt = VehicleSettingsResponses.VehicleSettingsSettingNameSelection;
options.Prompt = sc.Context.Activity.CreateReply(settingNamePrompt, ResponseBuilder);
var card = new ThumbnailCard
{
Images = new List <CardImage> {
new CardImage(GetSettingCardImageUri(FallbackSettingImageFileName))
},
Text = "Please choose from one of the available settings shown below",
Buttons = options.Choices.Select(choice =>
new CardAction(ActionTypes.ImBack, choice.Value, value: choice.Value)).ToList(),
};
options.Prompt.Attachments.Add(card.ToAttachment());
// Default Text property is clumsy for speech
var speakOptions = options.Choices.Select(choice => choice.Value.ToString()).ToList();
options.Prompt.Speak = $"{options.Prompt.Text} {string.Join(",", speakOptions)}";
return(await sc.PromptAsync(Actions.SettingNameSelectionPrompt, options));
}
else
{
// Only one setting detected so move on to next stage
return(await sc.NextAsync());
}
case Luis.VehicleSettings.Intent.VEHICLE_SETTINGS_CHECK:
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply("The skill doesn't support checking vehicle settings quite yet!"));
return(await sc.EndDialogAsync(true, cancellationToken));
default:
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(VehicleSettingsResponses.VehicleSettingsOutOfDomain));
return(await sc.EndDialogAsync(true, cancellationToken));
}
}
//private async Task<DialogTurnResult> QuestionsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
//{
// return await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// {
// Prompt = MessageFactory.Text("Please enter your programming question.")
// }, cancellationToken);
//}
private async Task <DialogTurnResult> CallGenerateAnswerAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
//stepContext.Values["Question1"] = (string)stepContext.Result;
//stepContext.Values["question"] = (string)stepContext.Result;
var qnaMakerOptions = new QnAMakerOptions
{
ScoreThreshold = DefaultThreshold,
Top = DefaultTopN,
};
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Humm... Searching...😊"), cancellationToken);
await stepContext.Context.SendActivitiesAsync(
new Activity[] {
new Activity {
Type = ActivityTypes.Typing
},
new Activity {
Type = "delay", Value = 7000
},
},
cancellationToken);
//stepContext.Values["Question"] = (string)stepContext.Result;
var response = await _services.QnAMakerService.GetAnswersAsync(stepContext.Context, qnaMakerOptions);
//if ( i < 0.5)
//{
// await stepContext.Context.SendActivityAsync(MessageFactory.Text("Sorry 😞,No QnAMaker answers found for your programming question."), cancellationToken);
//}
if (response != null && response.Length > 0)
{
float i = response[0].Score;
//await stepContext.Context.SendActivityAsync(MessageFactory.Text("No QnAMaker answers found for your programming question."), cancellationToken);
if (response.Length >= 1 && i >= 0.9)
{
//for (int j = 0; j < response.Length; j++)
//{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("I found the following results from your question"), cancellationToken);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
{
Prompt = MessageFactory.Text(response[0].Answer),
}, cancellationToken);
// }
}
if (response.Length == 1 && i <= 0.9 && i >= 0.5)
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("I found the following results from your question"), cancellationToken);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
{
Prompt = MessageFactory.Text(response[0].Answer),
}, cancellationToken);
}
if (response.Length > 1 && i > 0.5)
{
var options = response.Select(r => r.Questions[0]).ToList();
var herocard = new HeroCard();
herocard.Text = "Did you mean:";
List <CardAction> buttons = new List <CardAction>();
foreach (var item in options)
{
buttons.Add(new CardAction()
{
Type = ActionTypes.ImBack,
Title = item.ToString(),
Value = item.ToString()
});
}
buttons.Add(new CardAction()
{
Type = ActionTypes.ImBack,
Title = "None of the above.",
Value = "Cancel."
});
herocard.Buttons = buttons;
var response1 = stepContext.Context.Activity.CreateReply();
response1.Attachments = new List <Attachment>()
{
herocard.ToAttachment()
};
await stepContext.Context.SendActivityAsync(response1);
}
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
else
{
//await stepContext.Context.SendActivityAsync(MessageFactory.Text("Sorry 😞,No QnAMaker answers found for your programming question."), cancellationToken);
await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
{
Prompt = MessageFactory.Text("Sorry 😞,No QnAMaker answers found for your programming question."),
}, cancellationToken);
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
//switch (response.Length)
//{
// case 0:
// await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// {
// Prompt = MessageFactory.Text("No QnAMaker answers found."),
// }, cancellationToken);
// break;
// case 1:
// await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// {
// Prompt = MessageFactory.Text(response[0].Answer),
// }, cancellationToken);
// break;
// //case 2:
// // for (int i = 0; i < response.Length; i++)
// // {
// // await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// // {
// // Prompt = MessageFactory.Text(response[i].Answer),
// // }, cancellationToken);
// // }
// // break;
// default:
// var options = response.Select(r => r.Questions[0]).ToList();
// var herocard = new HeroCard();
// herocard.Text = "Did you mean:";
// List<CardAction> buttons = new List<CardAction>();
// foreach (var item in options)
// {
// buttons.Add(new CardAction()
// {
// Type = ActionTypes.ImBack,
// Title = item.ToString(),
// Value = item.ToString()
// });
// }
// buttons.Add(new CardAction()
// {
// Type = ActionTypes.ImBack,
// Title = "None of the above.",
// Value = "None of the above."
// });
// herocard.Buttons = buttons;
// var response1 = stepContext.Context.Activity.CreateReply();
// response1.Attachments = new List<Attachment>() { herocard.ToAttachment() };
// await stepContext.Context.SendActivityAsync(response1);
// break;
//}
//return await qnaMaker.GetAnswersAsync(stepContext.Context, qnaMakerOptions);
// var response = await _services.GetAnswersRawAsync(stepContext.Context, qnaMakerOptions).ConfigureAwait(false);
//if (response != null && response.Length > 0)
//{
//int i = 0;
//int id = response[0].Id;
//ID.QuestionID = id;
//do
//{
// await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// {
// Prompt = MessageFactory.Text(response[i].Answer),
// }, cancellationToken);
// //i=i+1;
// i++;
//} while (i < response.Length);
//await QuestionConfirmStepAsync(stepContext, cancellationToken);
//await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { }, cancellationToken);
//return await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { }, cancellationToken);
//QuestionConfirmStepAsync(stepContext, cancellationToken);
//QuestionConfirmStepAsync(stepContext,cancellationToken);
//}
//else
//{
// //return await stepContext.Context.SendActivityAsync(MessageFactory.Text("No QnA Maker answers were found."), cancellationToken);
// await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions
// {
// Prompt = MessageFactory.Text("I could not find an answer to your question. Please rephrase your question, so that I can better understand it."),
// }, cancellationToken);
// //return await stepContext.ContinueDialogAsync();
// return await stepContext.EndDialogAsync(null, cancellationToken);
//}
}
private static async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
await stepContext.Context.SendActivityAsync($"Hello {stepContext.Result}, nice to meet you!", cancellationToken : cancellationToken);
return(await stepContext.EndDialogAsync(stepContext.Result, cancellationToken));
}
public async Task <DialogTurnResult> AfterUpdateStartTime(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var events = new List <EventModel>();
var calendarAPI = GraphClientHelper.GetCalendarService(state.APIToken, state.EventSource, ServiceManager.GetGoogleClient());
var calendarService = ServiceManager.InitCalendarService(calendarAPI, state.EventSource);
if (state.OriginalStartDate != null || state.OriginalStartTime != null)
{
events = await GetEventsByTime(state.OriginalStartDate, state.OriginalStartTime, state.OriginalEndDate, state.OriginalEndTime, state.GetUserTimeZone(), calendarService);
state.OriginalStartDate = null;
state.OriginalStartTime = null;
state.OriginalEndDate = null;
state.OriginalStartTime = null;
}
else if (state.Title != null)
{
events = await calendarService.GetEventsByTitle(state.Title);
state.Title = null;
}
else
{
DateTime?startTime = null;
sc.Context.Activity.Properties.TryGetValue("OriginText", out var content);
var userInput = content != null?content.ToString() : sc.Context.Activity.Text;
try
{
IList <DateTimeResolution> dateTimeResolutions = sc.Result as List <DateTimeResolution>;
if (dateTimeResolutions.Count > 0)
{
startTime = DateTime.Parse(dateTimeResolutions.First().Value);
var dateTimeConvertType = dateTimeResolutions.First().Timex;
bool isRelativeTime = IsRelativeTime(sc.Context.Activity.Text, dateTimeResolutions.First().Value, dateTimeResolutions.First().Timex);
startTime = isRelativeTime ? TimeZoneInfo.ConvertTime(startTime.Value, TimeZoneInfo.Local, state.GetUserTimeZone()) : startTime;
}
}
catch
{
}
if (startTime != null)
{
startTime = TimeConverter.ConvertLuisLocalToUtc(startTime.Value, state.GetUserTimeZone());
events = await calendarService.GetEventsByStartTime(startTime.Value);
}
else
{
state.Title = userInput;
events = await calendarService.GetEventsByTitle(userInput);
}
}
state.Events = events;
if (events.Count <= 0)
{
return(await sc.BeginDialogAsync(Actions.UpdateStartTime, new UpdateDateTimeDialogOptions(UpdateDateTimeDialogOptions.UpdateReason.NoEvent)));
}
else if (events.Count > 1)
{
var options = new PromptOptions()
{
Choices = new List <Choice>(),
};
for (var i = 0; i < events.Count; i++)
{
var item = events[i];
var choice = new Choice()
{
Value = string.Empty,
Synonyms = new List <string> {
(i + 1).ToString(), item.Title
},
};
options.Choices.Add(choice);
}
var replyToConversation = sc.Context.Activity.CreateReply(UpdateEventResponses.MultipleEventsStartAtSameTime);
replyToConversation.AttachmentLayout = AttachmentLayoutTypes.Carousel;
replyToConversation.Attachments = new List <Microsoft.Bot.Schema.Attachment>();
var cardsData = new List <CalendarCardData>();
foreach (var item in events)
{
var meetingCard = item.ToAdaptiveCardData(state.GetUserTimeZone());
var replyTemp = sc.Context.Activity.CreateAdaptiveCardReply(CalendarMainResponses.GreetingMessage, item.OnlineMeetingUrl == null ? "Dialogs/Shared/Resources/Cards/CalendarCardNoJoinButton.json" : "Dialogs/Shared/Resources/Cards/CalendarCard.json", meetingCard);
replyToConversation.Attachments.Add(replyTemp.Attachments[0]);
}
options.Prompt = replyToConversation;
return(await sc.PromptAsync(Actions.EventChoice, options));
}
else
{
return(await sc.EndDialogAsync(true));
}
}
catch
{
await sc.Context.SendActivityAsync(sc.Context.Activity.CreateReply(CalendarSharedResponses.CalendarErrorMessage, ResponseBuilder));
var state = await Accessor.GetAsync(sc.Context);
state.Clear();
return(await sc.CancelAllDialogsAsync());
}
}
protected async Task <DialogTurnResult> HandleMore(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
var luisResult = state.LuisResult;
var topIntent = luisResult?.TopIntent().intent;
var topGeneralIntent = state.GeneralLuisResult?.TopIntent().intent;
if (topIntent == null)
{
return(await sc.EndDialogAsync(true));
}
sc.Context.Activity.Properties.TryGetValue("OriginText", out var content);
var userInput = content != null?content.ToString() : sc.Context.Activity.Text;
await DigestFocusEmailAsync(sc);
var skillOptions = (EmailSkillDialogOptions)sc.Options;
skillOptions.SubFlowMode = true;
if (topIntent == EmailLuis.Intent.Delete)
{
return(await sc.BeginDialogAsync(Actions.Delete, skillOptions));
}
else if (topIntent == EmailLuis.Intent.Forward)
{
return(await sc.BeginDialogAsync(Actions.Forward, skillOptions));
}
else if (topIntent == EmailLuis.Intent.Reply)
{
return(await sc.BeginDialogAsync(Actions.Reply, skillOptions));
}
else if (IsReadMoreIntent(topGeneralIntent, userInput) ||
(topIntent == EmailLuis.Intent.ShowNext || topIntent == EmailLuis.Intent.ShowPrevious || topGeneralIntent == General.Intent.ShowPrevious || topGeneralIntent == General.Intent.ShowNext))
{
return(await sc.ReplaceDialogAsync(Actions.Display, skillOptions));
}
else
{
await DigestEmailLuisResult(sc, state.LuisResult, true);
await SearchEmailsFromList(sc, cancellationToken);
if (state.MessageList.Count > 0)
{
return(await sc.ReplaceDialogAsync(Actions.DisplayFiltered, skillOptions));
}
// return a signal for main flow need to start a new ComponentDialog.
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(EmailSharedResponses.DidntUnderstandMessage));
return(await sc.EndDialogAsync(true));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> HandleAgeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Personal Details collected"));
return(await stepContext.EndDialogAsync(cancellationToken));
}
protected async Task <DialogTurnResult> ShowFilteredEmails(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
if (state.MessageList.Count > 0)
{
if (state.Message.Count == 0)
{
state.Message.Add(state.MessageList[0]);
if (state.MessageList.Count > 1)
{
var importCount = 0;
foreach (var msg in state.MessageList)
{
if (msg.Importance.HasValue && msg.Importance.Value == Importance.High)
{
importCount++;
}
}
await ShowMailList(sc, state.MessageList, state.MessageList.Count(), importCount, cancellationToken);
return(await sc.NextAsync());
}
else if (state.MessageList.Count == 1)
{
return(await sc.ReplaceDialogAsync(Actions.Read, options : sc.Options));
}
}
else
{
return(await sc.ReplaceDialogAsync(Actions.Read, options : sc.Options));
}
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(EmailSharedResponses.DidntUnderstandMessage));
return(await sc.EndDialogAsync(true));
}
else
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(EmailSharedResponses.EmailNotFound));
}
return(await sc.EndDialogAsync(true));
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> ActStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var command = stepContext.Result.ToString();
if (command.ToLower().Contains("choose image"))
{
int imageIndex = await GetImageIndex(stepContext);
BingImageService imageService = new BingImageService();
DailyChallengeImage image = await tableService.getDailyChallengeImage();
BingMapService mapService = new BingMapService(Configuration["BingMapsAPI"]);
Logger.LogInformation("Image Text: " + image.ImageText);
DailyChallengeEntry challengeEntry = await mapService.GetLocationDetails(image.ImageText, Logger);
if (challengeEntry == null)
{
Logger.LogError("Unable to retrieve details of image");
throw new Exception("Unable to retrieve details from Google");
}
Logger.LogInformation("Image Response: " + challengeEntry.imageResponse);
Logger.LogInformation("Longitude: " + challengeEntry.longitude);
Logger.LogInformation("Latitude: " + challengeEntry.latitude);
Logger.LogInformation("Latitude: " + challengeEntry.distanceFrom);
var dailyChallenge = await tableService.GetDailyChallenge();
dailyChallenge.photoUrl = image.Url;
dailyChallenge.text = image.ImageText;
dailyChallenge.latitude = challengeEntry.latitude;
dailyChallenge.longitude = challengeEntry.longitude;
dailyChallenge.extractedLocation = challengeEntry.imageResponse;
dailyChallenge.entries = new List <DailyChallengeEntry>();
dailyChallenge.publishedTime = DateTime.Now;
dailyChallenge.currentStatus = DailyChallengeStatus.Guessing;
await tableService.SaveDailyChallenge(dailyChallenge);
IMessageActivity reply = MessageFactory.Attachment(new List <Attachment>());
reply.Attachments.Add(AttachmentHelper.ImageChosen(dailyChallenge.photoUrl));
var activity = (Activity)reply;
await stepContext.Context.SendActivityAsync((Activity)reply);
return(await stepContext.EndDialogAsync(cancellationToken));
//return await stepContext.ReplaceDialogAsync(nameof(ChallengeGuesserDialog), promptOptions, cancellationToken);
}
else if (command.ToLower().Contains("try another image"))
{
int imageIndex = await IncrementAndReturnImageIndex();
}
else if (command.ToLower().Contains("switch to google"))
{
try
{
var reply = MessageFactory.Attachment(new List <Attachment>());
var attachment = await GetGoogleImageChoiceAttachment();
await UpdateImageSource(ImageSource.Google);
reply.Attachments.Add(attachment);
}
catch (Exception exp)
{
Logger.LogError(exp, $"Could not set Google Image: {exp.Message} - {exp.StackTrace}", null);
throw exp;
}
}
else if (command.ToLower().Contains("switch to bing"))
{
var reply = MessageFactory.Attachment(new List <Attachment>());
int imageIndex = await GetImageIndex(stepContext);
await UpdateImageSource(ImageSource.Bing);
var attachment = await GetBingImageChoiceAttachment(imageIndex);
// reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
reply.Attachments.Add(attachment);
}
else
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Sorry, not sure about that"), cancellationToken);
}
return(await stepContext.BeginDialogAsync(nameof(MainDialog), null, cancellationToken));
}
private async Task <DialogTurnResult> ProcessResultsAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// To demonstrate that the slot dialog collected all the properties we will echo them back to the user.
if (stepContext.Result is IDictionary <string, object> result && result.Count > 0)
{
var form = (IDictionary <string, object>)result["fullname"];
// Now the waterfall is complete, save the data we have gathered into UserState.
var obj = await _userStateAccessor.GetAsync(stepContext.Context, () => new JObject());
obj["data"] = new JObject
{
{ "fullname", $"{form["first"]} {form["weight"]} {form["last"]}" },
};
var diagnosis = new DiaBOT.Posts.Diagnosis
{
EDAD = (int)form["age"],
GENERO = (int)form["gender"],
PADRES = (int)form["parents"],
HERMANOS = (int)form["siblings"],
HIJOS = (int)form["child"],
OTROS = (int)form["member"],
ACTIVIDAD_FISICA = (int)form["gym"],
TABAQUISMO = (int)form["smoke"],
TUBERCULOSIS = (int)form["tuberculosis"],
CANCER = (int)form["cancer"],
OBESIDAD = (int)form["obesity"],
HIPERTENSION = (int)form["hypertense"],
VIH = (int)form["VIH"],
DEPRESION = (int)form["depresion"],
DISLIPIDEMIA = (int)form["dyslipidemic"],
CARDIO = (int)form["cardiovascular"],
HEPATITIS = (int)form["hepatitis"],
NUTRIOLOGO = (int)form["nutrition"],
OFTALMOLOGO = (int)form["oftalmologo"],
PODOLOGO = (int)form["podologo"],
MOTORA = (int)form["motriz"],
VISUAL = (int)form["visual"],
PESO = (int)form["weight"],
ESTATURA = (int)form["height"]
};
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://10.25.73.190:5000/evaluate");
var content = JsonConvert.SerializeObject(diagnosis);
Console.WriteLine(content);
var buffer = System.Text.Encoding.UTF8.GetBytes(content);
var bytes = new ByteArrayContent(buffer);
bytes.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var evaluation = client.PostAsync("", bytes).Result;
string txt = "Nothing";
if (evaluation.IsSuccessStatusCode)
{
txt = evaluation.Content.ReadAsStringAsync().Result;
Console.WriteLine(txt);
// txt = (yes > no) ? "Sorry, you have a high chance of diabetes" : "You seem pretty healthy, keep it up!";
}
await stepContext.Context.SendActivityAsync(MessageFactory.Text(txt), cancellationToken);
}
}
// Remember to call EndAsync to indicate to the runtime that this is the end of our waterfall.
return(await stepContext.EndDialogAsync());
}
private async Task <DialogTurnResult> ShowCardStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
_logger.LogInformation("MainDialog.ShowCardStepAsync");
// Reply to the activity we received with an activity.
var reply = stepContext.Context.Activity.CreateReply();
// Cards are sent as Attachments in the Bot Framework.
// So we need to create a list of attachments on the activity.
reply.Attachments = new List <Attachment>();
// Get the text from the activity to use to show the correct card
var text = stepContext.Context.Activity.Text.ToLowerInvariant().Split(' ')[0];
// Decide which type of card(s) we are going to show the user
if (text.StartsWith("hero"))
{
// Display a HeroCard.
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("HeroCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("thumb"))
{
// Display a ThumbnailCard.
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("ThumbnailCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("sign"))
{
// Display a SignInCard.
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("SigninCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("animation"))
{
// Display an AnimationCard.
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("AnimationCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("video"))
{
// Display a VideoCard
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("VideoCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("audio"))
{
// Display an AudioCard
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("AudioCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else if (text.StartsWith("receipt"))
{
// Display a ReceiptCard.
reply.Attachments.Add(Cards.GetReceiptCard().ToAttachment());
// Send the card(s) to the user as an attachment to the activity
await stepContext.Context.SendActivityAsync(reply, cancellationToken);
}
else if (text.StartsWith("adaptive"))
{
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("AdaptiveCard", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
else
{
// Display a carousel of all the rich card types.
string lgTemplateEvalResult = _lgEngine.EvaluateTemplate("AllCards", null);
IMessageActivity cardActivity = await _activityGenerator.CreateActivityFromText(lgTemplateEvalResult, null, stepContext.Context, _lgGenerator);
await stepContext.Context.SendActivityAsync(cardActivity);
}
// Give the user instructions about what to do next
await stepContext.Context.SendActivityAsync(MessageFactory.Text(_lgEngine.EvaluateTemplate("CardStartOverResponse", null)), cancellationToken);
return(await stepContext.EndDialogAsync());
}
private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var timex = ((List <DateTimeResolution>)stepContext.Result)[0].Timex;
return(await stepContext.EndDialogAsync(timex, cancellationToken));
}
private async Task <DialogTurnResult> ActStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
string result = stepContext.Context.Activity.Text;
MainDetail detail = new MainDetail();
//Luis 연동 체크
if (string.IsNullOrEmpty(Configuration["LuisAppId"]) || string.IsNullOrEmpty(Configuration["LuisAPIKey"]) || string.IsNullOrEmpty(Configuration["LuisAPIHostName"]))
{
detail = null;
}
else
{
detail = await luisHelper.ExecuteLuisQuery(Logger, stepContext.Context, cancellationToken);
}
//대화 의도에 따른 각각의 대화흐름 시작
switch (detail.intent)
{
case "버스":
return(await stepContext.BeginDialogAsync(nameof(BusInformationDialog), (BusDetails)detail, cancellationToken));
case "미세먼지":
return(await stepContext.BeginDialogAsync(nameof(WeatherInformationDialog), (DustDetails)detail, cancellationToken));
case "로그인":
return(await stepContext.BeginDialogAsync(nameof(LoginDialog), null, cancellationToken));
case "열람실":
return(await stepContext.BeginDialogAsync(nameof(ReadingRoomDialog), null, cancellationToken));
case "학식메뉴":
return(await stepContext.BeginDialogAsync(nameof(SchoolFoodDialog), null, cancellationToken));
case "트랙정보":
return(await stepContext.BeginDialogAsync(nameof(TrackInfoCardDialog), (TrackInfoCardDetail)detail, cancellationToken));
case "시간표":
return(await stepContext.BeginDialogAsync(nameof(PersonalTimeTableDialog), cancellationToken));
case "전화번호":
return(await stepContext.BeginDialogAsync(nameof(PhoneAdressDialog), (PhoneDetails)detail, cancellationToken));
case "교수님":
return(await stepContext.BeginDialogAsync(nameof(ProfessorsDialog), (ProfessorsDetail)detail, cancellationToken));
case "맛집":
return(await stepContext.BeginDialogAsync(nameof(MatjeepchoochunDialog), (MatjeepchoochunDetail)detail, cancellationToken));
case "공지사항":
return(await stepContext.BeginDialogAsync(nameof(NoticeDialog), (NoticeDetail)detail, cancellationToken));
case "장학제도":
await stepContext.Context.SendActivityAsync(MessageFactory.Text("https://www.hansung.ac.kr/web/www/life_02_01_t1"));
return(await stepContext.EndDialogAsync(null, cancellationToken));
default:
await stepContext.Context.SendActivityAsync(MessageFactory.Text("잘 이해하지 못했어요. 다시 질문해주세요"));
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
}
private async Task <DialogTurnResult> FinishCancelDialog(WaterfallStepContext sc, CancellationToken cancellationToken)
{
return(await sc.EndDialogAsync((bool)sc.Result));
}
private async Task <DialogTurnResult> FinalStepAsync(
WaterfallStepContext stepContext,
CancellationToken cancellationToken)
{
return(await stepContext.EndDialogAsync());
}
private async Task <DialogTurnResult> FinalAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var projectData = (ProjectData)stepContext.Options;
projectData.Date = (string)stepContext.Result;
try
{
string StatusSuccess = "0";
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
builder.DataSource = Configuration["DataSource"];
builder.UserID = Configuration["UserID"];
builder.Password = Configuration["Password"];
builder.InitialCatalog = Configuration["InitialCatalog"];
string dateString = projectData.Date;
string format = "dd/mm/yyyy";
DateTime dateTime = DateTime.ParseExact(dateString, format, CultureInfo.InvariantCulture);
string strNewDate = dateTime.ToString("yyyy-mm-dd");
using (SqlConnection connection = new SqlConnection(builder.ConnectionString))
{
connection.Open();
StringBuilder sb = new StringBuilder();
sb.Append("Insert into task(pdi_engineer_id,task,task_datetime) values('" + projectData.EmployeeID + "','" + projectData.Workstatus + "','" + strNewDate + "')");
String sql = sb.ToString();
using (SqlCommand command = new SqlCommand(sql, connection))
{
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.RecordsAffected == 1)
{
StatusSuccess = "1";
}
else
{
StatusSuccess = "0";
}
}
}
connection.Close();
if (StatusSuccess == "1")
{
projectData.EmployeeName = null;
projectData.EmployeeID = 0;
projectData.Date = null;
projectData.Workstatus = null;
StatusSuccess = "0";
projectData.intentIdenified = null;
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Work Status is submitted successfully."), cancellationToken);
return(await stepContext.BeginDialogAsync(nameof(MainDialog), projectData, cancellationToken));
}
else
{
projectData.EmployeeName = null;
projectData.EmployeeID = 0;
projectData.Date = null;
projectData.Workstatus = null;
StatusSuccess = "0";
projectData.intentIdenified = null;
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Work Status is not updated.\nPlease try again!"), cancellationToken);
return(await stepContext.BeginDialogAsync(nameof(MainDialog), projectData, cancellationToken));
}
}
}
catch (SqlException e)
{
Console.WriteLine(e.ToString());
}
var confirm = "Getstatus";
return(await stepContext.EndDialogAsync(confirm, cancellationToken));
}
public async Task <DialogTurnResult> ShowEventsSummary(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var tokenResponse = sc.Result as TokenResponse;
var state = await Accessor.GetAsync(sc.Context);
var options = sc.Options as ShowMeetingsDialogOptions;
if (state.SummaryEvents == null)
{
// this will lead to error when test
if (string.IsNullOrEmpty(state.APIToken))
{
state.Clear();
return(await sc.EndDialogAsync(true));
}
var calendarService = ServiceManager.InitCalendarService(state.APIToken, state.EventSource);
var searchDate = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, state.GetUserTimeZone());
if (state.StartDate.Any())
{
searchDate = state.StartDate.Last();
}
var results = await GetEventsByTime(new List <DateTime>() { searchDate }, state.StartTime, state.EndDate, state.EndTime, state.GetUserTimeZone(), calendarService);
var searchedEvents = new List <EventModel>();
bool searchTodayMeeting = SearchesTodayMeeting(state);
foreach (var item in results)
{
if (!searchTodayMeeting || item.StartTime >= DateTime.UtcNow)
{
searchedEvents.Add(item);
}
}
if (searchedEvents.Count == 0)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowNoMeetingMessage));
state.Clear();
return(await sc.EndDialogAsync(true));
}
else
{
if (options != null && options.Reason == ShowMeetingReason.ShowOverviewAgain)
{
var responseParams = new StringDictionary()
{
{ "Count", searchedEvents.Count.ToString() },
{ "DateTime", state.StartDateString ?? CalendarCommonStrings.Today }
};
if (searchedEvents.Count == 1)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowOneMeetingSummaryAgainMessage, responseParams));
}
else
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowMeetingSummaryAgainMessage, responseParams));
}
}
else
{
var responseParams = new StringDictionary()
{
{ "Count", searchedEvents.Count.ToString() },
{ "EventName1", searchedEvents[0].Title },
{ "DateTime", state.StartDateString ?? CalendarCommonStrings.Today },
{ "EventTime1", SpeakHelper.ToSpeechMeetingTime(TimeConverter.ConvertUtcToUserTime(searchedEvents[0].StartTime, state.GetUserTimeZone()), searchedEvents[0].IsAllDay == true) },
{ "Participants1", DisplayHelper.ToDisplayParticipantsStringSummary(searchedEvents[0].Attendees) }
};
if (searchedEvents.Count == 1)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowOneMeetingSummaryMessage, responseParams));
}
else
{
responseParams.Add("EventName2", searchedEvents[searchedEvents.Count - 1].Title);
responseParams.Add("EventTime2", SpeakHelper.ToSpeechMeetingTime(TimeConverter.ConvertUtcToUserTime(searchedEvents[searchedEvents.Count - 1].StartTime, state.GetUserTimeZone()), searchedEvents[searchedEvents.Count - 1].IsAllDay == true));
responseParams.Add("Participants2", DisplayHelper.ToDisplayParticipantsStringSummary(searchedEvents[searchedEvents.Count - 1].Attendees));
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowMultipleMeetingSummaryMessage, responseParams));
}
}
}
await ShowMeetingList(sc, GetCurrentPageMeetings(searchedEvents, state), !searchTodayMeeting);
state.SummaryEvents = searchedEvents;
if (state.SummaryEvents.Count == 1)
{
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()));
}
}
else
{
var currentPageMeetings = GetCurrentPageMeetings(state.SummaryEvents, state);
if (options != null && options.Reason == ShowMeetingReason.ShowFilteredMeetings)
{
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowMultipleFilteredMeetings, new StringDictionary()
{
{ "Count", state.SummaryEvents.Count.ToString() }
}));
}
else
{
var responseParams = new StringDictionary()
{
{ "Count", state.SummaryEvents.Count.ToString() },
{ "EventName1", currentPageMeetings[0].Title },
{ "DateTime", state.StartDateString ?? CalendarCommonStrings.Today },
{ "EventTime1", SpeakHelper.ToSpeechMeetingTime(TimeConverter.ConvertUtcToUserTime(currentPageMeetings[0].StartTime, state.GetUserTimeZone()), currentPageMeetings[0].IsAllDay == true) },
{ "Participants1", DisplayHelper.ToDisplayParticipantsStringSummary(currentPageMeetings[0].Attendees) }
};
await sc.Context.SendActivityAsync(ResponseManager.GetResponse(SummaryResponses.ShowMeetingSummaryNotFirstPageMessage, responseParams));
}
await ShowMeetingList(sc, GetCurrentPageMeetings(state.SummaryEvents, state), !SearchesTodayMeeting(state));
}
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = ResponseManager.GetResponse(SummaryResponses.ReadOutMorePrompt) }));
}
catch (SkillException ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> EndAskForFaceImageDialog(WaterfallStepContext step, CancellationToken cancellationToken = default(CancellationToken))
{
//ending dialog
return(await step.EndDialogAsync(step.ActiveDialog.State));
}
public async Task <DialogTurnResult> AfterConfirmRecipient(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
if (state.NameList != null && state.NameList.Count > 0)
{
// result is null when just update the recipient name. show recipients page should be reset.
if (sc.Result == null)
{
state.ShowRecipientIndex = 0;
return(await sc.BeginDialogAsync(Actions.ConfirmRecipient));
}
var choiceResult = (sc.Result as FoundChoice)?.Value.Trim('*');
if (choiceResult != null)
{
if (choiceResult == General.Intent.Next.ToString())
{
state.ShowRecipientIndex++;
return(await sc.BeginDialogAsync(Actions.ConfirmRecipient));
}
if (choiceResult == UpdateUserDialogOptions.UpdateReason.TooMany.ToString())
{
state.ShowRecipientIndex++;
return(await sc.BeginDialogAsync(Actions.ConfirmRecipient, new UpdateUserDialogOptions(UpdateUserDialogOptions.UpdateReason.TooMany)));
}
if (choiceResult == General.Intent.Previous.ToString())
{
if (state.ShowRecipientIndex > 0)
{
state.ShowRecipientIndex--;
}
return(await sc.BeginDialogAsync(Actions.ConfirmRecipient));
}
var recipient = new Recipient();
var emailAddress = new EmailAddress
{
Name = choiceResult.Split(": ")[0],
Address = choiceResult.Split(": ")[1],
};
recipient.EmailAddress = emailAddress;
if (state.Recipients.All(r => r.EmailAddress.Address != emailAddress.Address))
{
state.Recipients.Add(recipient);
}
state.ConfirmRecipientIndex++;
}
if (state.ConfirmRecipientIndex < state.NameList.Count)
{
return(await sc.BeginDialogAsync(Actions.ConfirmRecipient));
}
}
// save emails
foreach (var email in state.EmailList)
{
var recipient = new Recipient();
var emailAddress = new EmailAddress
{
Name = email,
Address = email,
};
recipient.EmailAddress = emailAddress;
if (state.Recipients.All(r => r.EmailAddress.Address != emailAddress.Address))
{
state.Recipients.Add(recipient);
}
}
return(await sc.EndDialogAsync(true));
}
catch (Exception ex)
{
throw await HandleDialogExceptions(sc, ex);
}
}
private async Task <DialogTurnResult> Show(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
await stepContext.Context.SendActivityAsync("Todavía no está implementado");
return(await stepContext.EndDialogAsync());
}
