private async Task OnOptionSelected(IDialogContext context, IAwaitable <string> result)
{
try
{
//capture which option then selected
string optionSelected = await result;
if (optionSelected == OrderNumber)
{
context.Call(dialogFactory.Create <OrderNumber>(), this.ResumeAfterOptionDialog);
}
if (optionSelected == OrderAccount)
{
context.Call(dialogFactory.Create <OrderAccount>(), this.ResumeAfterOptionDialog);
}
if (optionSelected == OrderDate)
{
context.Call(dialogFactory.Create <OrderDate>(), this.ResumeAfterOptionDialog);
}
}
catch (TooManyAttemptsException ex)
{
//This sets us in a waiting state, after running the prompt again.
await this.MessageReceivedAsync(context);
}
}
private async Task ResumeAfterOptionSelected(IDialogContext context, IAwaitable <string> result)
{
var option = await result;
if (option == null)
{
context.Done <object>(null);
return;
}
if (option.Equals(Resources.HelpDialog_start_over, StringComparison.OrdinalIgnoreCase))
{
context.Call(dialogFactory.Create <IDialog <object> >(), null);
return;
}
if (option.Equals(Resources.HelpDialog_connect_operator, StringComparison.OrdinalIgnoreCase))
{
context.Call(dialogFactory.Create <HandoverDialog>(), null);
return;
}
if (option.Equals(Resources.HelpDialog_end, StringComparison.OrdinalIgnoreCase))
{
await context.SayAsync(Resources.goodbye);
return;
}
await StartAsync(context);
}
private async Task OnMessageRecieved(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var activity = await result;
if (activity.AsEventActivity() != null && activity.ChannelData != null)
{
try
{
var callParamsResponse = JsonConvert.DeserializeObject <GetCallParamsResponse>((string)activity.ChannelData.ToString());
var personId = callParamsResponse.CallParams.ValueOrDefault(ClientCallPredefParam.GUEST_IDENTITY);
if (personId != null)
{
personId = personId.Replace(" ", "").RemoveDiacritics();
context.Call(dialogFactory.Create <MainDialog, string>(personId), onFinished);
return;
}
}
catch (Exception)
{
context.Call(dialogFactory.Create <MainDialog, string>(null), onFinished);
return;
}
}
if (maxAttempts > 0)
{
maxAttempts--;
await AskCallParams(context);
context.Wait(OnMessageRecieved);
return;
}
context.Call(dialogFactory.Create <MainDialog, string>(null), onFinished);
}
public async Task StartAsync(IDialogContext context)
{
try
{
var shoppingList = new ShoppingListDto()
{
Id = new Guid(),
Items = new List <ShoppingItemDto>()
};
context.UserData.SetValue("CurrentShoppingListId", shoppingList.Id);
await context.PostAsync(MessagesResource.CreatedList);
await context.PostAsync(MessagesResource.AskWhatToAdd);
context.Call(_dialogFactory.Create <GetProductsByUserTask>(), Callback);
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
private async Task OnMessageReceived(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var activity = await result;
switch (activity.Text)
{
case BroadcasterCommand.Exit:
_repository.SetBroadcaster(context.Activity.From.Id, context.Activity.ChannelId, false);
await context.PostAsync("bye :(");
context.Done(true);
return;
case BroadcasterCommand.SendFeedback:
context.Call(_factory.Create <SendFeedbackDialog>(activity), ResumeAsync);
break;
case BroadcasterCommand.SendMessage:
context.Call(_factory.Create <SendMessageDialog>(activity), ResumeAsync);
break;
default:
context.Wait(OnMessageReceived);
break;
}
}
public void OnOneDialogButton()
{
var dialog = new OneButtonDialogUseCase("ダイアログのタイトル", "ダイアログの本文");
dialog.OnClose.Subscribe(_ => Debug.Log("１ボタンダイアログを閉じた"));
dialogFactory.Create(dialog);
}
public virtual void ShowOpenFileDialog(IOpenFileDialogViewModel model)
{
var dialog = _dialogFactory.Create <OpenFileDialog, IOpenFileDialogViewModel>(model);
dialog.ViewModel = model;
dialog.ShowDialog();
_dialogFactory.Release(dialog);
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var message = await result;
var itemSelected = JsonConvert.DeserializeObject <ProductSelectionPayload>(message.Text, new JsonSerializerSettings {
Error = delegate(object sender, ErrorEventArgs args) { args.ErrorContext.Handled = true; }
});
if (itemSelected != null)
{
if (itemSelected.Action == "add")
{
var sender = new SendConfirmProductAdded(context);
await sender.Send();
}
context.Call(_dialogFactory.Create <GetPromoProductByCardTask>(), Callback);
}
else
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.CourtesyProductError);
var productsList = context.UserData.GetValueOrDefault <List <ProductDto> >("LastRecommendationProducts");
var sender = new SendCorrectProductsListCard(context);
await sender.Send(productsList);
context.Wait(GetTask);
}
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
private async Task ExecuteAfterForm(IDialogContext context, IAwaitable <ChooseJokes> result)
{
var data = await result;
var message = context.MakeMessage();
message.Text = data.JokeType.GetDescribe();
await context.Forward(dialogFactory.Create <JokeDialog>(), ExecuteAfterJokeDialog, message, CancellationToken.None);
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var userResponse = await result;
var luisResult = await LuisHelper.GetIntentAndEntitiesFromLUIS(userResponse.Text);
switch (luisResult.TopScoringIntent.Intent)
{
case LuisIntent.Yes:
{
await context.PostAsync(MessagesResource.AddOtherProducts);
context.Call(_dialogFactory.Create <GetProductsByUserTask>(), Callback);
break;
}
case LuisIntent.No:
{
context.Call(_dialogFactory.Create <AskIfWantSuggestionProductsTask>(), Callback);
break;
}
default:
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.CourtesyChooseError);
var sender = new SendCorrectYesOrNoCard(context);
await sender.Send(MessagesResource.AskIfWantAddProduct);
context.Wait(GetTask);
}
break;
}
}
}
public IDialog GetDialog(IDialogContext context, LuisResult luisResult)
{
switch (luisResult.TopScoringIntent.Intent)
{
case LuisIntent.None:
{
return _dialogFactory.Create<GreetingDialog>();
}
case LuisIntent.Greetings:
{
return _dialogFactory.Create<GreetingDialog>();
}
case LuisIntent.CreateNewList:
{
return _dialogFactory.Create<CreateNewShoppingListDialog>();
}
case LuisIntent.OpenLastList:
{
return _dialogFactory.Create<OpenLastShoppingListDialog>();
}
case LuisIntent.GetTimetables:
{
return _dialogFactory.Create<OpeningHoursDialog>();
}
case LuisIntent.GetPromo:
{
return _dialogFactory.Create<PromoProductsByCategoryDialog>();
}
default:
{
return _dialogFactory.Create<GreetingDialog>();
}
}
}
public async Task StartAsync(IDialogContext context)
{
try
{
var askIfWantProductPosition = new AskIfWantProductPosition(context);
await askIfWantProductPosition.Send();
new HandleUserIncorrectInput(context).ResetCounter();
context.Wait(GetTask);
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
public virtual async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
await result;
}
catch (TooManyAttemptsException)
{
context.Call(dialogFactory.Create <HelpDialog, bool>(false), null);
return;
}
var message = await result;
//Some bug in PromptDialog.Choice causes message.Type to be null
if (message.Text == null) //message.Type != ActivityTypes.Message)
{
context.Wait(MessageReceivedAsync);
return;
}
if (conversationReference == null)
{
conversationReference = message.ToConversationReference();
}
if (message.Text.ContainsAnyIgnoreCaseAndAccents(Resources.WelcomeMessage_operator, "clovek"))
{
await CheckAvailableOperators(context);
return;
}
if (message.Text.ContainsAnyIgnoreCaseAndAccents(Resources.MluviiDialog_virtual_assistant, "virtual", "asistent", "bot", "assistent"))
{
await OnBotSelected(context);
return;
}
await context.SayAsync(Resources.RetryText);
await StartOver(context);
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var productsSelected = await result;
await context.PostAsync(MessagesResource.AskIfContinueToAddProduct);
new HandleUserIncorrectInput(context).ResetCounter();
context.Call(_dialogFactory.Create <AskIfAddAnotherProductTask>(), Callback);
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
private IWindow CreateDialog(
Type dialogType,
INotifyPropertyChanged ownerViewModel,
INotifyPropertyChanged viewModel)
{
var dialog = dialogFactory.Create(dialogType);
dialog.Owner = FindOwnerWindow(ownerViewModel);
dialog.DataContext = viewModel;
return(dialog);
}
public async Task StartAsync(IDialogContext context)
{
PromptDialog.Choice(context, async(dialogContext, result) =>
{
var choice = await result;
DebugOptions selected;
Enum.TryParse <DebugOptions>(choice, out selected);
var dialog = dialogFactory.Create <MainDialog, DebugOptions>(selected);
dialogContext.Call(dialog, null);
},
new[] { "GotoFinalConfirmation", "GotoOperatorSearch", "GotoMap" },
"DEBUG MENU");
}
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => _dialogueFactory.Create((int)DialogueType.InitialDialog));
}
else
{
HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var message = await result;
var luidData = await LuisHelper.GetIntentAndEntitiesFromLUIS(message.Text);
var dialog = _dialogFactory.Create <RootDialogFactory>().GetDialog(context, luidData);
if ((luidData.TopScoringIntent.Intent != LuisIntent.Greetings) && (dialog.GetType().ToString() == "GreetingDialog"))
{
await context.PostAsync(MessagesResource.CourtesyError);
}
context.Call(dialog, Callback);
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
var dialog = dialogFactory.Create <RootDialog>();
await Conversation.SendAsync(activity, () => dialog);
}
else
{
await this.HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var activity = await result;
if (activity.Text == "i wanna broadcast")
{
var dialog = _dialogFactory.Create <BroadcasterDialog>(activity);
context.Call(dialog, OnAfterBroadcastingResume);
}
else
{
await context.PostAsync("shhhhh... just listen");
context.Wait(MessageReceivedAsync);
}
}
private async Task OnOperatorSelected(IDialogContext context, IAwaitable <string> result)
{
string selectedOpe = null;
try
{
selectedOpe = await result;
}
catch (TooManyAttemptsException)
{
context.Call(dialogFactory.Create <HelpDialog, bool>(false), null);
return;
}
var selected = availibleOperators.AvailableOperators.SingleOrDefault(ope => ope.DisplayName.Equals(selectedOpe));
context.Done(selected);
}
public async Task PostAsync(IActivity item, object state, CancellationToken token)
{
var message = item as IMessageActivity;
if (message != null)
{
var helpDialog = dialogFactory.Create <HelpDialog>();
// wrap it with an additional dialog that will restart the wait for
// messages from the user once the child dialog has finished
var interruption = helpDialog.Void <object, IMessageActivity>();
// put the interrupting dialog on the stack
task.Call(interruption, null);
// start running the interrupting dialog
await task.PollAsync(token);
}
}
void IInitializable.Initialize()
{
_contexts
.ObserveAdd()
.Select(x => x.Value.Dialog)
.Subscribe(x => {
x.OnNextAsObservable()
.Subscribe(y => _onOpen.OnNext(y))
.AddTo(_disposable);
x.OnPreviousAsObservable()
.Subscribe(y => _onClose.OnNext(y))
.AddTo(_disposable);
})
.AddTo(_disposable);
Observable
.Merge(_intent.OnOpenAsObservable().Where(_ => !_isOpen.Value), _onOpen)
.Select(request => {
Context context = null;
if (!_contexts.TryGetValue(request.Type, out context))
{
var dialogObject = _factory.Create(request.Type);
context = new Context()
{
Dialog = dialogObject.GetComponent <IDialog>(),
Object = dialogObject,
};
_contexts.Add(request.Type, context);
}
return(new Request()
{
Dialog = context.Dialog,
Param = request.Param,
});
})
.Where(x => x.Dialog != null)
.SelectMany(x => {
if (_stack.Count > 0)
{
return(_stack.Peek().Dialog.OnCloseAsObservable().First().Select(_ => x));
}
else
{
return(Observable.Return(x));
}
})
.Do(x => {
_stack.Push(x);
_isOpen.Value = true;
})
.SelectMany(x => x.Dialog.OnOpenAsObservable().First().Select(_ => x))
.SelectMany(x => x.Dialog.OnStartAsObservable(x.Param).First())
.Subscribe()
.AddTo(_disposable);
var close = _onClose
.Where(_ => _stack.Count > 0)
.SelectMany(x => _stack.Pop().Dialog.OnCloseAsObservable()
.First()
.Select(_ => x))
.Publish()
.RefCount();
close
.Where(_ => _stack.Count <= 0)
.Subscribe(x => {
_isOpen.Value = false;
_intent.Close(x);
})
.AddTo(_disposable);
close
.Where(_ => _stack.Count > 0)
.Select(_ => _stack.Peek())
.SelectMany(x => x.Dialog.OnResumeAsObservable(x.Param).First())
.Subscribe()
.AddTo(_disposable);
}
public async Task NoneIntent(IDialogContext context, LuisResult result)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var userResponse = await result;
var luisResult = await LuisHelper.GetIntentAndEntitiesFromLUIS(userResponse.Text);
var recommendationResult = new RecommendationDto()
{
Matcher = new MatcherResponse()
{
Results = new List <MatcherItem>()
{
new MatcherItem()
{
Id = 3034,
Raw = "pasta",
Score = 0.6,
Type = "Category"
},
new MatcherItem()
{
Id = 3034,
Raw = "pizza",
Score = 0.6,
Type = "Category"
},
new MatcherItem()
{
Id = 3034,
Raw = "vino",
Score = 0.6,
Type = "Category"
}
}
},
Products = new List <ProductDto>()
{
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 1",
Id = 1,
SKU = "1"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 2",
Id = 2,
SKU = "2"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 3",
Id = 3,
SKU = "3"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 4",
Id = 4,
SKU = "4"
}
}
};
context.UserData.SetValue("LastRecommendationProducts", recommendationResult.Products);
context.UserData.SetValue("LastRecommendationMatcher", recommendationResult.Matcher);
switch (luisResult.TopScoringIntent.Intent)
{
case LuisIntent.Yes:
{
if (recommendationResult.Products.Count > minSuggestionProductNumber)
{
context.Call(_dialogFactory.Create <GetSuggestionProductByCardTask>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.NoSuggestionProduct);
context.Call(_dialogFactory.Create <GetPromoProductByCardTask>(), Callback);
}
break;
}
case LuisIntent.No:
{
context.Call(_dialogFactory.Create <AskIfWantProductPositionTask>(), Callback);
break;
}
default:
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.CourtesyChooseError);
var sender = new SendCorrectYesOrNoCard(context);
await sender.Send(MessagesResource.AskIfWantSuggestions);
context.Wait(GetTask);
}
break;
}
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var message = await result;
var itemSelected = JsonConvert.DeserializeObject <ProductSelectionPayload>(message.Text, new JsonSerializerSettings {
Error = delegate(object sender, ErrorEventArgs args) { args.ErrorContext.Handled = true; }
});
if (itemSelected != null)
{
switch (itemSelected.Action)
{
case "add":
{
var product = itemSelected.Product;
context.UserData.SetValue("SelectedCategoryPromoProduct", product);
context.Call(_dialogFactory.Create <AskWhatListMustUsedTask>(), Callback);
break;
}
case "cancel":
{
var sender = new SendCorrectGreetingCard(context);
await sender.Send();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
break;
}
default:
break;
}
}
else
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.NotUnderstoodRequest);
await context.PostAsync(MessagesResource.SelectProduct);
var productsList = context.UserData.GetValueOrDefault <List <ProductDto> >("CategoryPromoProducts");
var sendProductsListCard = new SendCorrectProductsListCard(context);
await sendProductsListCard.Send(productsList);
context.Wait(GetTask);
}
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var message = await result;
var luisResult = await LuisHelper.GetIntentAndEntitiesFromLUIS(message.Text);
var product = context.UserData.GetValue <ProductDto>("SelectedCategoryPromoProduct");
switch (luisResult.TopScoringIntent.Intent)
{
case LuisIntent.CreateNewList:
case LuisIntent.OpenLastList:
{
if (luisResult.TopScoringIntent.Intent == LuisIntent.CreateNewList)
{
var shoppingList = new ShoppingListDto()
{
Id = new Guid(),
Items = new List <ShoppingItemDto>()
{
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "pasta",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
},
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "vino",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
},
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "pizza",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
}
}
};
context.UserData.SetValue("CurrentShoppingListId", shoppingList.Id);
}
context.Call(_dialogFactory.Create <AskIfAddAnotherProductTask>(), Callback);
break;
}
default:
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.CourtesyChooseError);
var sender = new SendCorrectListChooseCard(context);
await sender.Send();
context.Wait(GetTask);
}
break;
}
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
public async Task GetTask(IDialogContext context, IAwaitable <IMessageActivity> result)
{
try
{
var userResponse = await result;
var categorySelected = JsonConvert.DeserializeObject <OptionSelectionPayload>(userResponse.Text, new JsonSerializerSettings {
Error = delegate(object sender, ErrorEventArgs args) { args.ErrorContext.Handled = true; }
});
if (categorySelected != null)
{
switch (categorySelected.Action)
{
case "add":
{
var products = new List <ProductDto>()
{
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 1",
Id = 1,
SKU = "1"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 2",
Id = 2,
SKU = "2"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 3",
Id = 3,
SKU = "3"
},
new ProductDto()
{
CategoryId = 3034,
Description = "prodotto 4",
Id = 4,
SKU = "4"
}
};
context.UserData.SetValue("CategoryPromoProducts", products);
if (products.Count == 0)
{
await context.PostAsync(MessagesResource.NoPromoProductForCategorySelected);
await context.PostAsync(MessagesResource.SelectAnotherCategory);
var clusters = new List <ClusterDto>()
{
new ClusterDto()
{
Description = "prodotto 1",
Id = 1
},
new ClusterDto()
{
Description = "prodotto 2",
Id = 2
},
new ClusterDto()
{
Description = "prodotto 3",
Id = 3
},
new ClusterDto()
{
Description = "prodotto 4",
Id = 4
}
};
var sender = new SendCorrectCategoriesListCard(context);
await sender.Send(clusters);
context.Wait(GetTask);
}
else
{
context.Call(_dialogFactory.Create <GetCategoryPromoProductByCardTask>(), Callback);
}
break;
}
case "cancel":
{
var sender = new SendCorrectGreetingCard(context);
await sender.Send();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
break;
}
}
else
{
var handler = new HandleUserIncorrectInput(context);
if (handler.CheckCounterErrors())
{
await handler.UserErrorLimitExceeded();
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
else
{
await context.PostAsync(MessagesResource.CourtesyCategoryError);
var clusters = new List <ClusterDto>()
{
new ClusterDto()
{
Description = "prodotto 1",
Id = 1
},
new ClusterDto()
{
Description = "prodotto 2",
Id = 2
},
new ClusterDto()
{
Description = "prodotto 3",
Id = 3
},
new ClusterDto()
{
Description = "prodotto 4",
Id = 4
}
};
var sender = new SendCorrectCategoriesListCard(context);
await sender.Send(clusters);
context.Wait(GetTask);
}
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
private void StartDialogWithResumeAfter <TDialog>(IDialogContext context) where TDialog : IDialog <object>
{
context.Call(dialogFactory.Create <TDialog>(), this.ResumeAfterOptionDialog);
}
public async Task StartAsync(IDialogContext context)
{
try
{
var shoppingList = new ShoppingListDto()
{
Id = new Guid(),
Items = new List <ShoppingItemDto>()
{
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "pasta",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
},
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "vino",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
},
new ShoppingItemDto()
{
CategoryId = 3034,
Color = Pin.Gray,
Description = "pizza",
Id = context.UserData.Get <Guid>("CurrentShoppingListId")
}
}
};
if (shoppingList == null)
{
shoppingList = new ShoppingListDto()
{
Id = new Guid(),
Items = new List <ShoppingItemDto>()
};
await context.PostAsync(MessagesResource.EmptyShoppingList);
await context.PostAsync(MessagesResource.AskWhatToAdd);
context.Call(_dialogFactory.Create <GetProductsByUserTask>(), Callback);
}
else
{
if (shoppingList.Items.Count == 0)
{
await context.PostAsync(MessagesResource.EmptyShoppingList);
}
else
{
context.UserData.SetValue("CurrentShoppingListId", shoppingList.Id);
await context.PostAsync(MessagesResource.ShowShoppingListReview);
var sb = new StringBuilder();
foreach (var item in shoppingList.Items)
{
sb.Append(item.Description + "\n\n");
}
await context.PostAsync(sb.ToString());
}
context.Call(_dialogFactory.Create <AskIfAddAnotherProductTask>(), Callback);
}
}
catch (Exception ex)
{
await context.PostAsync(MessagesResource.CourtesyError);
context.Call(_dialogFactory.Create <GreetingDialog>(), Callback);
}
}
