/// <summary>
/// Called when the add alarm topic is started
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> StartTopic(IBotContext context)
{
var recognizedIntents = context.Get <IRecognizedIntents>();
var times = recognizedIntents.TopIntent?.Entities.Where(entity => entity.GroupName == "AlarmTime")
.Select(entity => DateTimeOffset.Parse(entity.ValueAs <string>()));
this.Alarm = new Alarm()
{
// initialize from intent entities
Title = recognizedIntents.TopIntent?.Entities.Where(entity => entity.GroupName == "AlarmTitle")
.Select(entity => entity.ValueAs <string>()).FirstOrDefault(),
// initialize from intent entities
Time = times.Where(t => t > DateTime.Now).FirstOrDefault()
};
if (Alarm.Time == default(DateTimeOffset))
{
// use today 1 HOUR as default
var defaultTime = DateTimeOffset.Now + TimeSpan.FromHours(1);
Alarm.Time = new DateTimeOffset(defaultTime.Year, defaultTime.Month, defaultTime.Day, defaultTime.Hour, 0, 0, DateTimeOffset.Now.Offset);
}
this.TopicState = TopicStates.AddingCard;
AddAlarmTopicResponses.ReplyWithStartTopic(context, this.Alarm);
return(true);
}
/// <summary>
/// we call for every turn while the topic is still active
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <bool> ContinueTopic(IBotContext context)
{
var recognizedIntents = context.Get <IRecognizedIntents>();
// for messages
if (context.Request.Type == ActivityTypes.Message)
{
switch (recognizedIntents.TopIntent?.Name)
{
case "showAlarms":
// allow show alarm to interrupt, but it's one turn, so we show the data without changing the topic
await new ShowAlarmsTopic().StartTopic(context);
return(true);
case "help":
// show contextual help
AddAlarmTopicResponses.ReplyWithHelp(context, this.Alarm);
return(true);
case "cancel":
// prompt to cancel
AddAlarmTopicResponses.ReplyWithCancelPrompt(context, this.Alarm);
this.TopicState = TopicStates.CancelConfirmation;
return(true);
default:
return(await ProcessTopicState(context));
}
}
return(true);
}
protected virtual async Task Write(IBotContext context)
{
StoreItems changes = new StoreItems();
var state = context.Get <StateT>(this._propertyName);
if (state == null)
{
state = new StateT();
}
var key = _keyDelegate(context);
changes[key] = state;
if (this._settings.LastWriterWins)
{
foreach (var item in changes)
{
if (item.Value is IStoreItem valueStoreItem)
{
valueStoreItem.eTag = "*";
}
}
}
await _storage.Write(changes).ConfigureAwait(false);
}
/// <summary>
/// Get a value of a specific type from a context object.
/// </summary>
/// <typeparam name="ObjectT">The value's type.</typeparam>
/// <param name="context">The context object.</param>
/// <param name="key">An optional lookup key. The default is the value type's name.</param>
/// <returns>The value.</returns>
public static ObjectT Get <ObjectT>(this IBotContext context, string key = null)
{
if (key == null)
{
key = $"{typeof(ObjectT).Namespace}.{typeof(ObjectT).Name}";
}
return((ObjectT)context.Get(key));
}
public static ObjectT Get <ObjectT>(this IBotContext context, string objectId = null)
{
if (objectId == null)
{
objectId = $"{typeof(ObjectT).Namespace}.{typeof(ObjectT).Name}";
}
return((ObjectT)context.Get(objectId));
}
/// <summary>
/// Called when the topic is started
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public Task <bool> StartTopic(IBotContext context)
{
var recognizedIntents = context.Get <IRecognizedIntents>();
this.AlarmTitle = recognizedIntents.TopIntent?.Entities.Where(entity => entity.GroupName == "AlarmTitle")
.Select(entity => entity.ValueAs <string>()).FirstOrDefault();
return(FindAlarm(context));
}
/// <summary>
/// outgoing activities
/// </summary>
/// <param name="context"></param>
/// <param name="activities"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task SendActivity(IBotContext context, IList <Activity> activities, MiddlewareSet.NextDelegate next)
{
foreach (var activity in activities)
{
IMessageActivity message = context.Request.AsMessageActivity();
if (!String.IsNullOrWhiteSpace(message?.Text))
{
// translate to userslanguage
var translationContext = context.Get <TranslationContext>();
if (translationContext.SourceLanguage != translationContext.TargetLanguage)
{
await TranslateMessageAsync(context, message, translationContext.TargetLanguage, translationContext.SourceLanguage).ConfigureAwait(false);
}
}
}
await next().ConfigureAwait(false);
}
/// <summary>
/// Continue the topic, method which is routed to while this topic is active
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public Task <bool> ContinueTopic(IBotContext context)
{
var conversation = ConversationState <ConversationData> .Get(context);
// var conversation = context.GetConversationState<ConversationData>();
var recognizedIntents = context.Get <IRecognizedIntents>();
switch (context.Request.Type)
{
case ActivityTypes.Message:
switch (recognizedIntents.TopIntent.Name)
{
case "addAlarm":
// switch to addAlarm topic
conversation.ActiveTopic = new AddAlarmTopic();
return(conversation.ActiveTopic.StartTopic(context));
case "showAlarms":
// switch to show alarms topic
conversation.ActiveTopic = new ShowAlarmsTopic();
return(conversation.ActiveTopic.StartTopic(context));
case "deleteAlarm":
// switch to delete alarm topic
conversation.ActiveTopic = new DeleteAlarmTopic();
return(conversation.ActiveTopic.StartTopic(context));
case "help":
// show help
DefaultTopicResponses.ReplyWithHelp(context);
return(Task.FromResult(true));
default:
// show our confusion
DefaultTopicResponses.ReplyWithConfused(context);
return(Task.FromResult(true));
}
default:
break;
}
return(Task.FromResult(true));
}
public static CustomState Get(IBotContext context)
{
return(context.Get <CustomState>(PropertyName));
}
/// <summary>
/// get the value of the ConversationState from the context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static StateT Get(IBotContext context)
{
return(context.Get <StateT>(PropertyName));
}
public async override Task OnReceiveActivity(IBotContext context)
{
// IMAGE
var image = context.Get <ImageRecognizeResult>(ImageMiddleware.ImageRecognizerResultKey);
if (image != null)
{
await context.SendActivity("Thaks for sending me a photo!\nLet's see...");
var keyword = image.PrimaryKeyword();
var finder = new Finder();
var result = await finder.SearchWithKeywordAsync(keyword);
if (result != null)
{
SearcherFeedbackState = true;
var activity = createReply(context, result);
await context.SendActivity(activity);
await context.SendActivity("Did you find what you ware looking for?");
return;
}
}
if ((context.Request.Type == ActivityTypes.Message) && (context.Request.AsMessageActivity().Text.Length > 0))
{
var message = context.Request.AsMessageActivity();
var qnamaker = new QnaMaker();
// If there is an active topic, let it handle this turn until it completes.
if (HasActiveTopic)
{
await ActiveTopic.OnReceiveActivity(context);
return;
}
if (!SearcherFeedbackState)
{
await context.SendActivity("Got it!");
}
// CHIT
var chitchater = new ChitChater();
var answer = await chitchater.SearchChitChat(message.Text);
if (answer != null)
{
await context.SendActivity(answer);
return;
}
// Feedback
if (SearcherFeedbackState)
{
SearcherFeedbackState = false;
var feedbacker = new Feedbacker();
var feedback = await feedbacker.SearchAsync(message.Text);
if (feedback == Feedbacker.INTENT.FEEDBACK_NEGATIVE)
{
await context.SendActivity("Sorry, but could you try agein using another term?");
return;
}
else if (feedback == Feedbacker.INTENT.FEEDBACK_POSITIVE)
{
await context.SendActivity("No problem!");
return;
}
// Not reterun and continue next line when you get NOEN intent.
}
// SelectQuestion
if (SelectQuestionState)
{
if (int.TryParse(message.Text, out i) && (i < 4))
{
var selectquestion = questionlist[i];
var selectanswer = await qnamaker.SearchQnaMaker(selectquestion);
await context.SendActivity(selectanswer.First().Answer);
SelectQuestionState = false;
SearcherFeedbackState = true;
return;
}
else if (turn < maxturn)
{
await context.SendActivity("Sorry,but please input number(1 - 4)");
turn += 1;
return;
}
else
{
SelectQuestionState = false;
await context.SendActivity("too many attempts");
await context.SendActivity("OK! You may change your mind.");
return;
}
}
// QnA
qnamaker = new QnaMaker();
var queryresults = await qnamaker.SearchQnaMaker(message.Text);
if (queryresults != null)
{
if (queryresults.First().Questions.Count() == 1)
{
SearcherFeedbackState = true;
await context.SendActivity(queryresults.First().Answer);
return;
}
else
{
SelectQuestionState = true;
SearcherFeedbackState = true;
var messages = "Did you mean? Please input number(1 - 4)";
foreach (var q in queryresults.First().Questions.Select((value, index) => new { value, index }))
{
if (q.index > 2)
{
messages += "\n\n" + "\n\n" + (q.index + 1) + ".None of adove";
questionlist.Add(queryresults.First().Questions[q.index]);
break;
}
messages += "\n\n" + "\n\n" + (q.index + 1) + "." + queryresults.First().Questions[q.index].ToString();
questionlist.Add(queryresults.First().Questions[q.index]);
}
await context.SendActivity(messages);
return;
}
}
// Search
var finder = new Finder();
var result = await finder.SearchAsync(message.Text);
if (result != null)
{
SearcherFeedbackState = true;
var activity = createReply(context, result);
await context.SendActivity(activity);
await context.SendActivity("Did you find what you ware looking for?");
return;
}
await context.SendActivity("Sorry, but I didn't understand that. Could you try saying that another way?");
}
}
/// <summary>
/// method for accessing recognized intents added by middleware to context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static IRecognizedIntents Get(IBotContext context)
{
return(context.Get <IRecognizedIntents>());
}
