protected async Task <DialogTurnResult> CheckReshow(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
var skillOptions = (EmailSkillDialogOptions)sc.Options;
skillOptions.SubFlowMode = true;
sc.Context.Activity.Properties.TryGetValue("OriginText", out var content);
var userInput = content != null?content.ToString() : sc.Context.Activity.Text;
var promptRecognizerResult = ConfirmRecognizerHelper.ConfirmYesOrNo(userInput, sc.Context.Activity.Locale);
if (promptRecognizerResult.Succeeded && promptRecognizerResult.Value == false)
{
var activity = TemplateEngine.GenerateActivityForLocale(EmailSharedResponses.CancellingMessage);
await sc.Context.SendActivityAsync(activity);
return(await sc.EndDialogAsync(true));
}
else if (promptRecognizerResult.Succeeded && promptRecognizerResult.Value == true)
{
return(await sc.ReplaceDialogAsync(Actions.Display, skillOptions));
}
return(await sc.NextAsync());
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
// This method is called by any waterfall step that throws a SkillException to ensure consistency
protected async Task HandleDialogExceptions(WaterfallStepContext sc, SkillException ex)
{
// send trace back to emulator
var trace = new Activity(type: ActivityTypes.Trace, text: $"DialogException: {ex.Message}, StackTrace: {ex.StackTrace}");
await sc.Context.SendActivityAsync(trace);
// log exception
TelemetryClient.TrackException(ex, new Dictionary <string, string> {
{ nameof(sc.ActiveDialog), sc.ActiveDialog?.Id }
});
// send error message to bot user
if (ex.ExceptionType == SkillExceptionType.APIAccessDenied)
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ToDoErrorMessageBotProblem);
await sc.Context.SendActivityAsync(activity);
}
else if (ex.ExceptionType == SkillExceptionType.AccountNotActivated)
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ToDoErrorMessageAccountProblem);
await sc.Context.SendActivityAsync(activity);
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ToDoErrorMessage);
await sc.Context.SendActivityAsync(activity);
}
// clear state
var state = await ToDoStateAccessor.GetAsync(sc.Context);
state.Clear();
}
private async Task <DialogTurnResult> CollectLocationPrompt(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
bool?isLocationSkipByDefault = false;
isLocationSkipByDefault = Settings.DefaultValue?.CreateMeeting?.First(item => item.Name == "EventLocation")?.IsSkipByDefault;
var state = await Accessor.GetAsync(sc.Context, cancellationToken : cancellationToken);
if (state.MeetingInfo.MeetingRoom != null)
{
state.MeetingInfo.Location = state.MeetingInfo.MeetingRoom.DisplayName;
return(await sc.EndDialogAsync());
}
else if (state.MeetingInfo.Location == null && (!(state.MeetingInfo.CreateHasDetail && isLocationSkipByDefault.GetValueOrDefault()) || state.MeetingInfo.RecreateState == RecreateEventState.Location))
{
var prompt = TemplateEngine.GenerateActivityForLocale(CreateEventResponses.NoLocation) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
else
{
return(await sc.NextAsync(cancellationToken : cancellationToken));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected Activity ToAdaptiveCardForTaskDeletedFlowByLG(
ITurnContext turnContext,
List <TaskItem> todos,
int allTasksCount,
string taskContent,
string listType,
bool isDeleteAll)
{
bool useFile = Channel.GetChannelId(turnContext) == Channels.Msteams;
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.TaskDeleted, new
{
IsDeleteAll = isDeleteAll,
ListType = listType,
TaskContent = taskContent,
Title = string.Format(ToDoStrings.CardTitle, listType),
TotalNumber = allTasksCount > 1 ? string.Format(ToDoStrings.CardMultiNumber, allTasksCount.ToString()) : string.Format(ToDoStrings.CardOneNumber, allTasksCount.ToString()),
ToDos = todos,
UseFile = useFile,
CheckIconUrl = useFile ? GetImageUri(IconImageSource.CheckIconFile) : IconImageSource.CheckIconSource,
UnCheckIconUrl = useFile ? GetImageUri(IconImageSource.UncheckIconFile) : IconImageSource.UncheckIconSource
});
return(activity);
}
private async Task <DialogTurnResult> AskForShowOverview(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
state.ShowMeetingInfo.Clear();
return(await sc.PromptAsync(Actions.TakeFurtherAction, new PromptOptions
{
Prompt = TemplateEngine.GenerateActivityForLocale(SummaryResponses.AskForShowOverview, new { DateTime = state.MeetingInfo.StartDateString ?? CalendarCommonStrings.TodayLower }) as Activity,
RetryPrompt = TemplateEngine.GenerateActivityForLocale(SummaryResponses.AskForShowOverview, new { DateTime = state.MeetingInfo.StartDateString ?? CalendarCommonStrings.TodayLower }) as Activity
}, cancellationToken));
}
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> CreateMeetingPrompt(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context, cancellationToken : cancellationToken);
var responseId = state.MeetingInfo.IsOrgnizerAvailable ? CheckPersonAvailableResponses.AskForCreateNewMeeting : CheckPersonAvailableResponses.AskForCreateNewMeetingAnyway;
var data = new
{
UserName = state.MeetingInfo.ContactInfor.Contacts[0].DisplayName ?? state.MeetingInfo.ContactInfor.Contacts[0].Address,
StartTime = TimeConverter.ConvertUtcToUserTime(state.MeetingInfo.StartDateTime.Value, state.GetUserTimeZone()).ToString(CommonStrings.DisplayTime)
};
return(await sc.PromptAsync(Actions.TakeFurtherAction, new PromptOptions
{
Prompt = TemplateEngine.GenerateActivityForLocale(responseId, data) as Activity,
RetryPrompt = TemplateEngine.GenerateActivityForLocale(responseId, data) as Activity,
}, cancellationToken));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected async Task <DialogTurnResult> AskListType(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
if (string.IsNullOrEmpty(state.ListType))
{
var prompt = TemplateEngine.GenerateActivityForLocale(DeleteToDoResponses.ListTypePromptForDelete);
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()
{
Prompt = prompt
}));
}
else
{
return(await sc.NextAsync());
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
public async Task <DialogTurnResult> AskRepeatFirstPageConfirmation(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
var taskCount = Math.Min(state.PageSize, state.AllTasks.Count);
var prompt = TemplateEngine.GenerateActivityForLocale(ShowToDoResponses.RepeatFirstPagePrompt, new
{
ListType = state.ListType,
TaskCount = taskCount
});
var retryPrompt = TemplateEngine.GenerateActivityForLocale(ShowToDoResponses.RepeatFirstPageConfirmFailed, new
{
ListType = state.ListType,
TaskCount = taskCount
});
return(await sc.PromptAsync(Actions.ConfirmPrompt, new PromptOptions()
{
Prompt = prompt, RetryPrompt = retryPrompt
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> GetEventsPrompt(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
if (state.ShowMeetingInfo.FocusedEvents.Any())
{
return(await sc.EndDialogAsync());
}
else if (state.ShowMeetingInfo.ShowingMeetings.Any())
{
return(await sc.NextAsync());
}
else
{
sc.Context.TurnState.TryGetValue(StateProperties.APITokenKey, out var token);
var calendarService = ServiceManager.InitCalendarService(token as string, state.EventSource);
return(await sc.PromptAsync(Actions.GetEventPrompt, new GetEventOptions(calendarService, state.GetUserTimeZone())
{
Prompt = TemplateEngine.GenerateActivityForLocale(UpdateEventResponses.NoUpdateStartTime),
RetryPrompt = TemplateEngine.GenerateActivityForLocale(UpdateEventResponses.EventWithStartTimeNotFound),
}, cancellationToken));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> PromptForNextAction(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
if (state.ShowMeetingInfo.ShowingMeetings.Count == 1)
{
// if only one meeting is showing, the prompt text is already included in show events step, prompt an empty message here
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()));
}
var prompt = TemplateEngine.GenerateActivityForLocale(SummaryResponses.ReadOutMorePrompt) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }));
}
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));
}
}
public async Task <DialogTurnResult> UpdateSubject(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
if (state.FindContactInfor.Contacts == null || state.FindContactInfor.Contacts.Count == 0)
{
state.FindContactInfor.FirstRetryInFindContact = true;
return(await sc.EndDialogAsync());
}
var recipientConfirmedMessage = TemplateEngine.GenerateActivityForLocale(EmailSharedResponses.RecipientConfirmed, new { userName = await GetNameListStringAsync(sc, false) });
var noSubjectMessage = TemplateEngine.GenerateActivityForLocale(SendEmailResponses.NoSubject);
noSubjectMessage.Text = recipientConfirmedMessage.Text + " " + noSubjectMessage.Text;
noSubjectMessage.Speak = recipientConfirmedMessage.Speak + " " + noSubjectMessage.Speak;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()
{
Prompt = noSubjectMessage as Activity
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> ConfirmNumber(WaterfallStepContext sc, CancellationToken cancellationToken)
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var selectedEvent = state.ShowMeetingInfo.FocusedEvents.First();
var phoneNumber = GetDialInNumberFromMeeting(selectedEvent);
var meetingLink = selectedEvent.OnlineMeetingUrl ?? GetTeamsMeetingLinkFromMeeting(selectedEvent);
var responseParams = new
{
PhoneNumber = phoneNumber,
MeetingLink = meetingLink
};
var responseName = phoneNumber == null ? JoinEventResponses.ConfirmMeetingLink : JoinEventResponses.ConfirmPhoneNumber;
return(await sc.PromptAsync(Actions.TakeFurtherAction, new PromptOptions()
{
Prompt = TemplateEngine.GenerateActivityForLocale(responseName, responseParams) as Activity,
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected async Task <DialogTurnResult> AfterAskContinueDeleteTask(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
var confirmResult = (bool)sc.Result;
if (confirmResult)
{
// reset some fields here
state.TaskIndexes = new List <int>();
state.MarkOrDeleteAllTasksFlag = false;
state.TaskContentPattern = null;
state.TaskContentML = null;
state.TaskContent = null;
// replace current dialog to continue deleting more tasks
return(await sc.ReplaceDialogAsync(Actions.DoDeleteTask));
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ActionEnded);
await sc.Context.SendActivityAsync(activity);
return(await sc.EndDialogAsync(true));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> AfterConfirmMeetingRoom(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context, cancellationToken : cancellationToken);
var confirmResult = (bool)sc.Result;
if (confirmResult)
{
state.MeetingInfo.MeetingRoom = state.MeetingInfo.UnconfirmedMeetingRoom.First();
return(await sc.EndDialogAsync());
}
else
{
state.MeetingInfo.IgnoredMeetingRoom.Add(state.MeetingInfo.UnconfirmedMeetingRoom.First().DisplayName + state.MeetingInfo.StartDateTime.ToString());
var activity = TemplateEngine.GenerateActivityForLocale(FindMeetingRoomResponses.IgnoreMeetingRoom);
await sc.Context.SendActivityAsync(activity);
return(await sc.ReplaceDialogAsync(Actions.RecreateMeetingRoom, cancellationToken : cancellationToken));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
// Creates the turn logic to use for the proactive message.
private BotCallbackHandler UpcomingEventContinueConversationCallback(EventModel eventModel, WaterfallStepContext sc)
{
sc.EndDialogAsync();
return(async(turnContext, token) =>
{
var responseString = string.Empty;
var responseParams = new
{
Minutes = (eventModel.StartTime - DateTime.UtcNow).Minutes.ToString(),
Attendees = string.Join(",", eventModel.Attendees.ToSpeechString(CommonStrings.And, attendee => attendee.DisplayName ?? attendee.Address)),
Title = eventModel.Title,
Location = eventModel.Location ?? string.Empty
};
if (!string.IsNullOrWhiteSpace(eventModel.Location))
{
responseString = UpcomingEventResponses.UpcomingEventMessageWithLocation;
}
else
{
responseString = UpcomingEventResponses.UpcomingEventMessage;
}
var activity = TemplateEngine.GenerateActivityForLocale(responseString, responseParams);
await turnContext.SendActivityAsync(activity);
});
}
protected async Task <DialogTurnResult> AskContinueAddTask(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
var prompt = TemplateEngine.GenerateActivityForLocale(AddToDoResponses.AddMoreTask, new
{
ListType = state.ListType
});
var retryPrompt = TemplateEngine.GenerateActivityForLocale(AddToDoResponses.AddMoreTaskConfirmFailed, new
{
ListType = state.ListType
});
return(await sc.PromptAsync(Actions.ConfirmPrompt, new PromptOptions()
{
Prompt = prompt, RetryPrompt = retryPrompt
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> ConfirmBeforeUpdate(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var newStartTime = (DateTime)state.UpdateMeetingInfo.NewStartDateTime;
var origin = state.ShowMeetingInfo.FocusedEvents[0];
var last = origin.EndTime - origin.StartTime;
origin.StartTime = newStartTime;
origin.EndTime = (newStartTime + last).AddSeconds(1);
var replyMessage = await GetDetailMeetingResponseAsync(sc, origin, UpdateEventResponses.ConfirmUpdate);
return(await sc.PromptAsync(Actions.TakeFurtherAction, new PromptOptions
{
Prompt = replyMessage,
RetryPrompt = TemplateEngine.GenerateActivityForLocale(UpdateEventResponses.ConfirmUpdateFailed) as Activity,
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected async Task <DialogTurnResult> AskTaskContent(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await this.ToDoStateAccessor.GetAsync(sc.Context);
if (!string.IsNullOrEmpty(state.TaskContentPattern) ||
!string.IsNullOrEmpty(state.TaskContentML) ||
!string.IsNullOrEmpty(state.ShopContent))
{
return(await sc.NextAsync());
}
else
{
var prompt = TemplateEngine.GenerateActivityForLocale(AddToDoResponses.AskTaskContentText);
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()
{
Prompt = prompt
}));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> GetNewEventTimePrompt(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
if (state.UpdateMeetingInfo.NewStartDate.Any() || state.UpdateMeetingInfo.NewStartTime.Any() || state.UpdateMeetingInfo.MoveTimeSpan != 0)
{
return(await sc.NextAsync());
}
return(await sc.PromptAsync(Actions.TimePrompt, new TimePromptOptions
{
Prompt = TemplateEngine.GenerateActivityForLocale(UpdateEventResponses.NoNewTime) as Activity,
RetryPrompt = TemplateEngine.GenerateActivityForLocale(UpdateEventResponses.NoNewTimeRetry) as Activity,
TimeZone = state.GetUserTimeZone(),
MaxReprompt = CalendarCommonUtil.MaxRepromptCount
}, cancellationToken));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
public async Task <DialogTurnResult> RetryCollectSubject(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await EmailStateAccessor.GetAsync(sc.Context);
if (sc.Result != null)
{
sc.Context.Activity.Properties.TryGetValue("OriginText", out var subject);
var subjectInput = subject != null?subject.ToString() : sc.Context.Activity.Text;
if (!EmailCommonPhrase.GetIsSkip(subjectInput))
{
state.Subject = subjectInput;
}
}
if (!string.IsNullOrWhiteSpace(state.Subject))
{
return(await sc.NextAsync());
}
var activity = TemplateEngine.GenerateActivityForLocale(SendEmailResponses.RetryNoSubject);
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions()
{
Prompt = activity as Activity
}));
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected async Task <DialogTurnResult> AskDeletionConfirmation(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
if (state.MarkOrDeleteAllTasksFlag)
{
var prompt = TemplateEngine.GenerateActivityForLocale(DeleteToDoResponses.AskDeletionAllConfirmation, new
{
ListType = state.ListType
});
var retryPrompt = TemplateEngine.GenerateActivityForLocale(DeleteToDoResponses.AskDeletionAllConfirmationFailed, new
{
ListType = state.ListType
});
return(await sc.PromptAsync(Actions.ConfirmPrompt, new PromptOptions()
{
Prompt = prompt, RetryPrompt = retryPrompt
}));
}
else
{
return(await sc.NextAsync());
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
public async Task <DialogTurnResult> AfterAskSecondReadMoreConfirmation(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
var confirmResult = (bool)sc.Result;
if (confirmResult)
{
state.ShowTaskPageIndex++;
return(await sc.EndDialogAsync(true));
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ActionEnded);
await sc.Context.SendActivityAsync(activity);
return(await sc.CancelAllDialogsAsync());
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
private async Task <DialogTurnResult> CreateEvent(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context, cancellationToken : cancellationToken);
var source = state.EventSource;
if (state.MeetingInfo.MeetingRoom != null)
{
state.MeetingInfo.ContactInfor.Contacts.Add(new EventModel.Attendee
{
DisplayName = state.MeetingInfo.MeetingRoom.DisplayName,
Address = state.MeetingInfo.MeetingRoom.EmailAddress,
AttendeeType = AttendeeType.Resource
});
}
var newEvent = new EventModel(source)
{
Title = state.MeetingInfo.Title,
Content = state.MeetingInfo.Content,
Attendees = state.MeetingInfo.ContactInfor.Contacts,
StartTime = (DateTime)state.MeetingInfo.StartDateTime,
EndTime = (DateTime)state.MeetingInfo.EndDateTime,
TimeZone = TimeZoneInfo.Utc,
Location = state.MeetingInfo.MeetingRoom == null ? state.MeetingInfo.Location : null,
};
sc.Context.TurnState.TryGetValue(StateProperties.APITokenKey, out var token);
var calendarService = ServiceManager.InitCalendarService(token as string, state.EventSource);
if (await calendarService.CreateEventAysnc(newEvent) != null)
{
var activity = TemplateEngine.GenerateActivityForLocale(CreateEventResponses.MeetingBooked);
await sc.Context.SendActivityAsync(activity);
}
else
{
var prompt = TemplateEngine.GenerateActivityForLocale(CreateEventResponses.EventCreationFailed) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
state.Clear();
return(await sc.EndDialogAsync(true, cancellationToken));
}
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> GreetUserAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
dynamic data = new { Name = stepContext.Result.ToString() };
var response = TemplateEngine.GenerateActivityForLocale("HaveNameMessage", data);
await stepContext.Context.SendActivityAsync(response);
return(await stepContext.NextAsync(cancellationToken : cancellationToken));
}
private async Task <DialogTurnResult> PromptForNameAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// NOTE: Uncomment the following lines to access LUIS result for this turn.
// var luisResult = stepContext.Context.TurnState.Get<LuisResult>(StateProperties.SkillLuisResult);
var prompt = TemplateEngine.GenerateActivityForLocale("NamePrompt");
return(await stepContext.PromptAsync(DialogIds.NamePrompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
private async Task <DialogTurnResult> ChangeEventStatus(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var options = (ChangeEventStatusDialogOptions)sc.Options;
sc.Context.TurnState.TryGetValue(StateProperties.APITokenKey, out var token);
var calendarService = ServiceManager.InitCalendarService(token as string, state.EventSource);
var deleteEvent = state.ShowMeetingInfo.FocusedEvents[0];
if (options.NewEventStatus == EventStatus.Cancelled)
{
if (deleteEvent.IsOrganizer)
{
await calendarService.DeleteEventByIdAsync(deleteEvent.Id);
}
else
{
await calendarService.DeclineEventByIdAsync(deleteEvent.Id);
}
var activity = TemplateEngine.GenerateActivityForLocale(ChangeEventStatusResponses.EventDeleted);
await sc.Context.SendActivityAsync(activity);
}
else
{
await calendarService.AcceptEventByIdAsync(deleteEvent.Id);
var activity = TemplateEngine.GenerateActivityForLocale(ChangeEventStatusResponses.EventAccepted);
await sc.Context.SendActivityAsync(activity);
}
if (options.SubFlowMode)
{
state.MeetingInfo.ClearTimes();
state.MeetingInfo.ClearTitle();
}
else
{
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));
}
}
private async Task <DialogTurnResult> ShowNextMeeting(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
// if only one next meeting, show the meeting detail card, otherwise show a meeting list card
if (state.ShowMeetingInfo.ShowingMeetings.Count == 1)
{
var speakParams = new
{
EventName = state.ShowMeetingInfo.ShowingMeetings[0].Title,
PeopleCount = state.ShowMeetingInfo.ShowingMeetings[0].Attendees.Count.ToString(),
EventTime = SpeakHelper.ToSpeechMeetingDateTime(
TimeConverter.ConvertUtcToUserTime(state.ShowMeetingInfo.ShowingMeetings[0].StartTime, state.GetUserTimeZone()),
state.ShowMeetingInfo.ShowingMeetings[0].IsAllDay == true),
Location = state.ShowMeetingInfo.ShowingMeetings[0].Location ?? string.Empty
};
if (string.IsNullOrEmpty(state.ShowMeetingInfo.ShowingMeetings[0].Location))
{
var activity = TemplateEngine.GenerateActivityForLocale(SummaryResponses.ShowNextMeetingNoLocationMessage, speakParams);
await sc.Context.SendActivityAsync(activity);
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(SummaryResponses.ShowNextMeetingMessage, speakParams);
await sc.Context.SendActivityAsync(activity);
}
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(SummaryResponses.ShowMultipleNextMeetingMessage);
await sc.Context.SendActivityAsync(activity);
}
state.ShowMeetingInfo.ShowingCardTitle = CalendarCommonStrings.UpcommingMeeting;
var reply = await GetGeneralMeetingListResponseAsync(sc, state, true);
await sc.Context.SendActivityAsync(reply);
state.Clear();
return(await sc.EndDialogAsync());
}
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> ConfirmNameList(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context);
var options = sc.Options as FindContactDialogOptions;
if (state.InitialIntent == CalendarLuis.Intent.CheckAvailability)
{
options.PromptMoreContact = false;
}
// got attendee name list already.
if (state.MeetingInfo.ContactInfor.ContactsNameList.Any())
{
if (options != null && options.FindContactReason == FindContactDialogOptions.FindContactReasonType.FirstFindContact)
{
if (state.MeetingInfo.ContactInfor.ContactsNameList.Count > 1)
{
options.PromptMoreContact = false;
}
}
return(await sc.NextAsync());
}
// ask for attendee
if (state.InitialIntent == CalendarLuis.Intent.CheckAvailability)
{
var prompt = TemplateEngine.GenerateActivityForLocale(CheckPersonAvailableResponses.AskForCheckAvailableUserName) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
if (state.InitialIntent == CalendarLuis.Intent.FindMeetingRoom)
{
var prompt = TemplateEngine.GenerateActivityForLocale(FindContactResponses.AddMoreAttendees) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
else if (options.FindContactReason == FindContactDialogOptions.FindContactReasonType.FirstFindContact)
{
var prompt = TemplateEngine.GenerateActivityForLocale(FindContactResponses.NoAttendees) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
else
{
var prompt = TemplateEngine.GenerateActivityForLocale(FindContactResponses.AddMoreAttendees) as Activity;
return(await sc.PromptAsync(Actions.Prompt, new PromptOptions { Prompt = prompt }, cancellationToken));
}
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
protected async Task <DialogTurnResult> AddTask(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await ToDoStateAccessor.GetAsync(sc.Context);
if (state.AddDupTask)
{
state.ListType = state.ListType ?? ToDoStrings.ToDo;
state.LastListType = state.ListType;
var service = await InitListTypeIds(sc);
var currentAllTasks = await service.GetTasksAsync(state.ListType);
var duplicatedTaskIndex = currentAllTasks.FindIndex(t => t.Topic.Equals(state.TaskContent, StringComparison.InvariantCultureIgnoreCase));
await service.AddTaskAsync(state.ListType, state.TaskContent);
state.AllTasks = await service.GetTasksAsync(state.ListType);
state.ShowTaskPageIndex = 0;
var rangeCount = Math.Min(state.PageSize, state.AllTasks.Count);
state.Tasks = state.AllTasks.GetRange(0, rangeCount);
var toDoListCard = ToAdaptiveCardForTaskAddedFlowByLG(
sc.Context,
state.Tasks,
state.TaskContent,
state.AllTasks.Count,
state.ListType);
await sc.Context.SendActivityAsync(toDoListCard);
return(await sc.NextAsync());
}
else
{
var activity = TemplateEngine.GenerateActivityForLocale(ToDoSharedResponses.ActionEnded);
await sc.Context.SendActivityAsync(activity);
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> AfterCollectBuildingPrompt(WaterfallStepContext sc, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var state = await Accessor.GetAsync(sc.Context, cancellationToken : cancellationToken);
var luisResult = sc.Context.TurnState.Get <CalendarLuis>(StateProperties.CalendarLuisResultKey);
if (luisResult.TopIntent().intent == CalendarLuis.Intent.RejectCalendar && luisResult.TopIntent().score > 0.8)
{
// '*' matches any buildings
state.MeetingInfo.Building = "*";
state.MeetingInfo.FloorNumber = null;
}
else if (sc.Result == null)
{
var activity = TemplateEngine.GenerateActivityForLocale(CalendarSharedResponses.RetryTooManyResponse);
await sc.Context.SendActivityAsync(activity);
state.Clear();
await sc.CancelAllDialogsAsync();
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
else
{
List <RoomModel> meetingRooms = sc.Result as List <RoomModel>;
if (state.MeetingInfo.Building == null)
{
state.MeetingInfo.Building = sc.Context.Activity.Text;
}
if (state.MeetingInfo.FloorNumber == null)
{
state.MeetingInfo.FloorNumber = meetingRooms[0].FloorNumber;
foreach (var room in meetingRooms)
{
if (room.FloorNumber != state.MeetingInfo.FloorNumber)
{
state.MeetingInfo.FloorNumber = null;
break;
}
}
}
}
return(await sc.EndDialogAsync());
}
catch (Exception ex)
{
await HandleDialogExceptions(sc, ex);
return(new DialogTurnResult(DialogTurnStatus.Cancelled, CommonUtil.DialogTurnResultCancelAllDialogs));
}
}
