async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
try
{
await inner.PostAsync(activity, token);
}
catch (Exception ex)
{
trace.WriteLine(ex.Message);
var messageActivity = activity.AsMessageActivity();
if (messageActivity != null)
{
await botToUser.PostAsync(messageProvider.GetMessage("ExceptionMessage"), cancellationToken : token);
await botToUser.PostAsync(messageProvider.GetMessage("WhatMoreCanIDo"), cancellationToken : token);
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, messageActivity))
{
var botData = scope.Resolve <IBotData>();
await botData.LoadAsync(default(CancellationToken));
var stack = scope.Resolve <IDialogStack>();
stack.Reset();
botData.ConversationData.Clear();
await botData.FlushAsync(default(CancellationToken));
}
}
}
}
public async Task PostAsync(IMessageActivity message,
CancellationToken cancellationToken = default(CancellationToken))
{
if (message.Text == "I’m Sorry, I don’t have an answer for you. Please try and rephrase your question")
{
//save to permanant storage here
//if you would like to use a database
//I have a very simple database bot example here
//https://github.com/JasonSowers/DatabaseBotExample
}
//user is the recipient
var userId = message.Recipient.Id;
//remove entry from dictionary
Utils.MessageDictionary.Remove(userId);
//this is just for testing purposes and can be removed
try
{
await inner.PostAsync($"{userId} - {Utils.MessageDictionary[userId]}");
}
catch (Exception e)
{
await inner.PostAsync($"No entry found for {userId}");
}
await inner.PostAsync((Activity)message, cancellationToken);
}
async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
try
{
await _inner.PostAsync(activity, token);
}
catch (Exception error)
{
try
{
if (Debugger.IsAttached)
{
var message = _botToUser.MakeMessage();
message.Text = $"Exception: { error.Message}";
message.Attachments = new[]
{
new Attachment(MediaTypeNames.Text.Plain, content: error.StackTrace)
};
await _botToUser.PostAsync(message, token);
}
else
{
await _botToUser.PostAsync("Ops! I'm still handle the previous message...", cancellationToken : token);
}
}
catch (Exception e)
{
_trace.WriteLine(e);
}
throw;
}
}
private static async Task EvaluateAndRespondToSentimentAsync(IBotToUser context, Sentiment sentiment, string languageCode)
{
// If there's no Sentiment object or score value, quit now.
if (sentiment?.Score == null)
{
return;
}
var sentimentResponse = string.Empty;
try
{
// Score ranges from 0.0 to 1, with 4 decimals of precision
if (sentiment.Score <= 0.1)
{
// If the sentiment is lower than 3%, respond with apologies and recommend to reach out to support
sentimentResponse = "I'm sorry you're having problems. If you'd like to talk to a person, please email [email protected] and they will be able to assist further.";
}
else if (sentiment.Score >= 0.95)
{
// if the sentiment is in the top 97%, respond with a reminder to leave a review for the app.
sentimentResponse = "I'm happy to see you're enjoying our services. Please consider leaving an app review after you're done today!";
}
// If there's no response needed, quit now.
if (string.IsNullOrEmpty(sentimentResponse))
{
return;
}
// Check to see if we need to translate the response.
if (languageCode != "en")
{
using (var translationClient = new TextTranslationServiceClient(SubscriptionKeys.TextTranslationServiceKey))
{
if (!string.IsNullOrEmpty(sentimentResponse))
{
var translationResult = await translationClient.TranslateAsync(sentimentResponse, languageCode);
var translatedSentimentResponse = translationResult.Translations.FirstOrDefault()?.Text;
if (!string.IsNullOrEmpty(translatedSentimentResponse))
{
// If we were able to translate the message, update the message we're sending.
sentimentResponse = translatedSentimentResponse;
}
}
}
}
// Reply with the sentiment response.
await context.PostAsync(sentimentResponse);
}
catch (Exception ex)
{
await context.PostAsync($"EvaluateAndRespondToSentimentAsync Exception: {ex.Message}");
}
}
/// <inheritdoc/>
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
await _botToUser.PostAsync($"Your conversation Id is:{item.Conversation.Id}.", cancellationToken : token);
await _botToUser.PostAsync($"Your dialog stack is:", cancellationToken : token);
foreach (var task in _task.Frames)
{
await _botToUser.PostAsync($"Task {task.Target.GetType()}.", cancellationToken : token);
}
}
/// <summary>執行階段：主要的對話處理程序，會從所有全域處理程序中執行最高分的項目</summary>
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
if (await _agentService.IsInExistingConversationAsync(item, token))
{
await _agentToUser.SendToUserAsync(item as Activity, token);
}
else
{
await _botToUser.PostAsync(ConversationText.NotTalkingWithAnyUser);
await _botToUser.PostAsync(ConversationText.NotTalkingWithBot);
}
}
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
if (await _agentService.IsInExistingConversationAsync(item, token))
{
await _agentToUser.SendToUserAsync(item as Activity, token);
}
else
{
await _botToUser.PostAsync("You are not talking with any user.");
await _botToUser.PostAsync("And sadly, you can't talk to me either. :(");
}
}
async Task IMessageQueue.DrainQueueAsync(IBotToUser botToUser, CancellationToken token)
{
while (this.queue.Count > 0)
{
var toUser = this.queue.Dequeue();
// last message in the queue will be treated specially for channels that need input hints
if (this.queue.Count == 0)
{
var stack = this.makeStack();
if (this.channelCapability.ShouldSetInputHint(toUser) && stack.Frames.Count > 0)
{
var topOfStack = stack.Frames[0].Target;
// if there is a prompt dialog on top of stack, the InputHint will be set to Expecting
if (topOfStack != null && topOfStack.GetType().DeclaringType == typeof(PromptDialog))
{
toUser.InputHint = InputHints.ExpectingInput;
}
else
{
toUser.InputHint = InputHints.AcceptingInput;
}
}
}
else
{
if (this.channelCapability.ShouldSetInputHint(toUser))
{
toUser.InputHint = InputHints.IgnoringInput;
}
}
await botToUser.PostAsync(toUser, token);
}
}
async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
try
{
await this.inner.PostAsync(activity, token);
}
catch (Exception error)
{
this.trace.WriteLine(error);
Log.Fatal(error, "Impossible to reply to the user because of an {Type} exception: '{Message}'", error.GetType(), error.Message);
try
{
var message = this.botToUser.MakeMessage();
message.Text = Resources.UnhandledException_Message;
AddExceptionToMessageAtDebug(message, error);
await botToUser.PostAsync(message, cancellationToken : token);
}
catch (Exception inner)
{
this.trace.WriteLine(inner);
Log.Fatal(inner, "Impossible to notify the user because of an {Type} exception: '{Message}'", inner.GetType(), inner.Message);
}
throw;
}
}
/// <summary>
/// Posts a typing (e.g. "...") message to user.
/// </summary>
public static Task PostTyping(this IBotToUser context)
{
var reply = context.MakeMessage();
reply.Type = ActivityTypes.Typing;
return(context.PostAsync(reply));
}
private static async Task SendMessageAsync(IBotToUser context, Attachment attachment)
{
var message = context.MakeMessage();
message.Attachments.Add(attachment);
await context.PostAsync(message);
}
private static async Task SendMessageAsync(IBotToUser context, string text)
{
var message = context.MakeMessage();
message.Text = text;
await context.PostAsync(message);
}
/// <summary>
/// Post a message to be sent to the bot, using previous messages to establish a conversation context.
/// </summary>
/// <param name="text">The message text.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task that represents the post operation.</returns>
public static async Task PostAsync(this IBotToUser botToUser, string text, CancellationToken cancellationToken = default(CancellationToken))
{
var message = botToUser.MakeMessage();
message.Text = text;
await botToUser.PostAsync(message, cancellationToken);
}
public async Task RenderAsync(List <ISesamError> errors)
{
var message = botToUser.MakeMessage();
message = BuildMessageFromErrors(errors, message);
await botToUser.PostAsync(message);
}
async Task IAlarmRenderer.RenderAsync(IBotToUser botToUser, string title, DateTime now)
{
Alarm alarm;
if (this.scheduler.TryFindAlarm(title, out alarm))
{
var card = new HeroCard();
card.Title = alarm.Title ?? "Default Alarm";
card.Subtitle = alarm.State
? (alarm.When.HasValue ? $"{alarm.When}" : "not set")
: "disabled";
IAlarmable query = alarm;
DateTime next;
if (query.TryFindNext(now, out next))
{
var remaining = next.Subtract(now);
bool today = now.Date == next.Date;
card.Text = $"There is {remaining:dd\\.hh\\:mm\\:ss} remaining before this alarm rings.";
}
var buttons = this.actions.ActionsFor(alarm);
card.Buttons = buttons.ToArray();
var message = botToUser.MakeMessage();
message.Attachments = new[] { card.ToAttachment() };
await botToUser.PostAsync(message);
}
else
{
throw new AlarmNotFoundException();
}
}
private static async Task ShowHelp(IBotToUser context)
{
await context.PostAsync("You can ask me about talks, rooms and speakers.\n\n" +
"Try asking: When is Tatham's talk?\n\n" +
"or\n\n" +
"What's happening on Red room?\n\n" +
"or\n\n" +
"What's going on at 3PM?");
}
protected override async Task PostAsync(IActivity item, string state, CancellationToken token)
{
this.stack.Reset();
botData.UserData.Clear();
botData.PrivateConversationData.Clear();
await botData.FlushAsync(token);
await botToUser.PostAsync(Resources.UserProfileDeleted);
}
async Task IScorable <IActivity, double> .PostAsync(IActivity message, object state, CancellationToken token)
{
this.stack.Reset();
botData.UserData.Clear();
botData.PrivateConversationData.Clear();
await botData.FlushAsync(token);
await botToUser.PostAsync(Resources.UserProfileDeleted);
}
private static async Task SendMessageAsync(IBotToUser context, List <HeroCard> cards, string title)
{
var message = context.MakeMessage();
message.Text = title;
message.AttachmentLayout = AttachmentLayoutTypes.Carousel;
message.Attachments = cards.Select(card => card.ToAttachment()).ToList();
await context.PostAsync(message);
}
/// <inheritdoc/>
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
_stack.Reset();
_botData.UserData.Clear();
_botData.PrivateConversationData.Clear();
_botData.ConversationData.Clear();
await _botData.FlushAsync(token);
await _botToUser.PostAsync("Profile Reset", cancellationToken : token);
}
async Task IScorable <double> .PostAsync <Item>(IPostToBot inner, Item item, object state, CancellationToken token)
{
var message = (IMessageActivity)(object)item;
this.stack.Reset();
botData.UserData.Clear();
botData.PrivateConversationData.Clear();
await botData.FlushAsync(token);
await botToUser.PostAsync(Resources.UserProfileDeleted);
}
async Task IMessageQueue.QueueMessageAsync(IBotToUser botToUser, IMessageActivity message, CancellationToken token)
{
// This assumes that if InputHint is set on message, it is the right value that channel expects
// and will NOT queue the message
if (this.channelCapability.ShouldSetInputHint(message))
{
// drain the queue
while (this.queue.Count > 0)
{
var toUser = this.queue.Dequeue();
toUser.InputHint = InputHints.IgnoringInput;
await botToUser.PostAsync(toUser, token);
}
queue.Enqueue(message);
}
else
{
await botToUser.PostAsync(message, token);
}
}
/// <summary>
/// Post a message to be sent to the bot, using previous messages to establish a conversation context.
/// </summary>
/// <remarks>
/// If the locale parameter is not set, locale of the incoming message will be used for reply.
/// </remarks>
/// <param name="botToUser">Communication channel to use.</param>
/// <param name="text">The message text.</param>
/// <param name="locale">The locale of the text.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task that represents the post operation.</returns>
public static async Task PostAsync(this IBotToUser botToUser, string text, string locale = null, CancellationToken cancellationToken = default(CancellationToken))
{
var message = botToUser.MakeMessage();
message.Text = text;
if (!string.IsNullOrEmpty(locale))
{
message.Locale = locale;
}
await botToUser.PostAsync(message, cancellationToken);
}
/// <summary>
/// Replay activity to IBotToUser.
/// </summary>
/// <param name="activity">Activity.</param>
/// <returns>Task.</returns>
public async Task Replay(IActivity activity)
{
if (activity is IMessageActivity)
{
var msg = _botToUser.MakeMessage();
msg.Text = _header(activity);
await _botToUser.PostAsync(msg);
var act = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(activity));
if (act.ChannelId != msg.ChannelId)
{
act.ChannelData = null;
}
act.From = msg.From;
act.Recipient = msg.Recipient;
act.ReplyToId = msg.ReplyToId;
act.ChannelId = msg.ChannelId;
act.Conversation = msg.Conversation;
await _botToUser.PostAsync(act);
}
}
async Task IPostToBot.PostAsync(IActivity activity, CancellationToken token)
{
try
{
await _inner.PostAsync(activity, token);
}
catch (Exception error)
{
var logger = LogManager.GetCurrentClassLogger();
logger.LogError("Unhandled exception during dialog.", error.Message, error.ToString(), activity.Conversation.Id);
try
{
if (Debugger.IsAttached)
{
var message = _botToUser.MakeMessage();
message.Text = $"Exception: { error }";
message.Attachments = new[]
{
new Attachment(MediaTypeNames.Text.Plain, content: error.StackTrace)
};
await _botToUser.PostAsync(message, token);
}
else
{
var message = _botToUser.MakeMessage();
message.Text = "Chatboten har støtt på et uventet problem. Vennligst prøv igjen senere eller ring oss";
await _botToUser.PostAsync(message, token);
}
}
catch (Exception inner)
{
_trace.WriteLine(inner);
logger.LogError("Unhandled exception during handling an error.", inner.Message, inner.ToString(), activity.Conversation.Id);
}
throw;
}
}
protected override async Task PostAsync(IActivity item, string state, CancellationToken token)
{
var message = item as IMessageActivity;
if (message != null)
{
var reply = _botToUser.MakeMessage();
reply.Text = answers.SelectRandomdly();
await _botToUser.PostAsync(reply);
}
}
public static async Task PostWithTranslationAsync(this IBotToUser context, string message, string messageLocale, string userLocale)
{
if (messageLocale == null)
{
throw new ArgumentNullException(nameof(messageLocale));
}
if (userLocale == null)
{
throw new ArgumentNullException(nameof(userLocale));
}
try
{
var bingTranslatorClient = new BingTranslatorClient("Test187871", "dAnT3r/eIc8KedBRUgRCV+juxpf4Wl312jn1Bd2SXzk=");
var translatedMessage = await bingTranslatorClient.Translate(message, messageLocale, userLocale);
await context.PostAsync(translatedMessage, userLocale);
}
catch (Exception e)
{
await context.PostAsync("Translator service problems, please try again later", "en-US");
}
}
public async Task PostAsync(IActivity activity, CancellationToken token)
{
try
{
await inner.PostAsync(activity, token);
}
catch (Exception ex)
{
try
{
await botToUser.PostAsync("Sorry that I'm unable to answer you in current context. Please try again later...", cancellationToken : token);
}
catch (Exception innerex)
{
trace.WriteLine(inner);
}
throw;
}
}
public async Task PostAsync(IActivity activity, CancellationToken token)
{
try
{
await inner.PostAsync(activity, token);
}
catch (Exception)
{
try
{
await botToUser.PostAsync("An Error Has Occurred.....", cancellationToken : token);
}
catch (Exception inner)
{
trace.WriteLine(inner);
}
throw;
}
}
/// <summary>執行階段：主要的對話處理程序，會從所有全域處理程序中執行最高分的項目</summary>
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
if (await _humanService.IsInExistingConversationAsync(item, token))
{
var message = item as Activity;
var agentAddress = new Agent(message).GetAddress();
var botData = await Utility.GetBotDataAsync(agentAddress, _botDataStore, token);
botData.PrivateConversationData.TryGetValue(Constants.USER_ROUTE_KEY, out Agent agent);
var reference = agent.ConversationReference;
var reply = reference.GetPostToUserMessage();
reply.Text = message?.Text;
await Utility.SendToConversationAsync(reply);
}
else
{
await _botToUser.PostAsync("您沒有與任何使用者對話", null, token);
}
}
