/// <summary>
/// Adds an assertion that the turn processing logic responds as expected.
/// </summary>
/// <param name="expected">The expected activity from the bot.</param>
/// <param name="description">A message to send if the actual response is not as expected.</param>
/// <param name="timeout">The amount of time in milliseconds within which a response is expected.</param>
/// <returns>A new <see cref="TestFlow"/> object that appends this assertion to the modeled exchange.</returns>
/// <remarks>This method does not modify the original <see cref="TestFlow"/> object.</remarks>
/// <exception cref="Exception">The bot did not respond as expected.</exception>
public TestFlow AssertReply(IActivity expected, [CallerMemberName] string description = null, uint timeout = 3000)
{
return(AssertReply(
(reply) =>
{
if (expected.Type != reply.Type)
{
throw new Exception($"{description}: Type should match");
}
if (expected.AsMessageActivity().Text != reply.AsMessageActivity().Text)
{
if (description == null)
{
throw new Exception($"Expected:{expected.AsMessageActivity().Text}\nReceived:{reply.AsMessageActivity().Text}");
}
else
{
throw new Exception($"{description}:\nExpected:{expected.AsMessageActivity().Text}\nReceived:{reply.AsMessageActivity().Text}");
}
}
},
description,
timeout));
}
public async Task LogAsync(IActivity activity)
{
string fromId = activity.From.Id;
string toId = activity.Recipient.Id;
string message = activity.AsMessageActivity().Text;
string insertQuery = "INSERT INTO userChatLog(fromId, toId, message) VALUES (@fromId,@toId,@message)";
// databases can be tricky beasts so use a try-catch block
try
{
// Passing the fromId, toId, message to the the user chatlog table
using (SqlCommand command = new SqlCommand(insertQuery, this.connection))
{
command.Parameters.AddWithValue("@fromId", fromId);
command.Parameters.AddWithValue("@toId", toId);
command.Parameters.AddWithValue("@message", message);
// Insert to SQL Server database
command.ExecuteNonQuery();
Debug.WriteLine("Insertion successful of message: " + activity.AsMessageActivity().Text);
}
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex.Message);
}
}
public Task LogAsync(IActivity activity)
{
var auditItem = new BotAuditItem()
{
TimestampUtc = activity.Timestamp,
SenderId = activity.From.Id,
SenderName = activity.From.Name,
RecipientId = activity.Recipient.Id,
RecipientName = activity.Recipient.Name,
//auditItem.UserId = ??? -- no idea how to get user id
ConversationId = activity.Conversation.Id,
ReplyToId = activity.ReplyToId,
MessageId = activity.Id
};
StringBuilder message = new StringBuilder();
// now try and fill in the message
var msg = activity.AsMessageActivity();
if (msg is Activity)
{
Activity a = msg as Activity;
foreach (var attachment in a.Attachments)
{
if (attachment.Content is HeroCard)
{
var card = attachment.Content as HeroCard;
message.AppendLine($"Sent HeroCard: {card.Text}");
}
else
{
message.AppendLine($"Sent Attachment: {attachment.ContentType}");
}
}
if (!String.IsNullOrEmpty(a.Text))
{
message.AppendLine($"{a.Text}");
}
}
else
{
message.AppendLine($"*** {activity.AsMessageActivity()?.Text}");
}
auditItem.Message = message.ToString();
Debug.WriteLine(auditItem);
// maybe in a real one we would
//return ApiManagerFactory.Instance.SaveAuditAsync(auditItem);
return(Task.CompletedTask);
}
/// <summary>
/// Get expected properties based on the <see cref="Activity"/>.Text that was used to recognize intent with in `RecognizeAsync`.
/// Telemetry properties logged should also differ, depending on value of <see cref="AdaptiveRecognizer.LogPersonalInformation"/>.
/// </summary>
/// <param name="activity">The activity used in `Recognizer.RecognizerAsync` to recognize intent with.</param>
/// <param name="result">The <see cref="RecognizerResult"/>.</param>
/// <param name="logPersonalInformation">Flag used to determine whether or not to log personally identifiable information.</param>
/// <returns>Dictionary of expected telemetry properties.</returns>
private static Dictionary <string, string> GetExpectedProps(IActivity activity, RecognizerResult result, bool logPersonalInformation)
{
var text = activity.AsMessageActivity().Text;
var expectedProps = ExpectedProperties.ContainsKey(text) ? ExpectedProperties[text]() : new Dictionary <string, string>();
if (logPersonalInformation)
{
expectedProps.Add("Text", activity.AsMessageActivity().Text);
expectedProps.Add("AlteredText", result.AlteredText);
}
return(expectedProps);
}
/// <summary>
/// Intercepts messages between BuddyBot and the user, logging them to the
/// <see cref="IChatHistoryWriter"/>.
/// </summary>
/// <param name="activity">Mandatory. Shared properties for all activities.</param>
/// <returns></returns>
public async Task LogAsync(IActivity activity)
{
if (activity.AsMessageActivity() != null)
{
ChatHistoryEntity chatHistoryEntity =
new ChatHistoryEntity($"{activity.ChannelId}:{activity.Type}", Guid.NewGuid().ToString())
{
From = activity.From.Id,
Recipient = activity.Recipient.Id,
Message = activity.AsMessageActivity().Text
};
await _chatHistoryWriter.SaveMessage(chatHistoryEntity);
}
}
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
var message = item.AsMessageActivity();
var response = await GetLoginAsync(message);
await BotToUser.PostAsync(response, token);
}
private async Task TrackMessageSentiment(IActivity activity, IDictionary <string, string> customProperties = null)
{
if (_settings.SentimentManager == null)
{
return;
}
var properties = await _settings.SentimentManager.GetSentimentProperties(activity.AsMessageActivity().Text);
if (properties != null)
{
//if there are custom properties, also add them.
if (customProperties != null)
{
foreach (var kvp in customProperties)
{
if (!properties.ContainsKey(kvp.Key))
{
properties.Add(kvp.Key, kvp.Value);
}
}
}
var et = BuildEventTelemetry(activity, properties);
et.Name = TelemetryEventTypes.MessageSentiment;
_telemetryClients.ForEach(c => c.TrackEvent(et));
}
}
public async Task LogAsync(IActivity activity)
{
if (activity.ChannelData != default(dynamic))
{
Trace.TraceInformation("[Channel Data]" + JsonConvert.SerializeObject(activity).Replace(Environment.NewLine, ""));
}
try
{
var tokenEntity = activity.AsMessageActivity().Entities.Where(e => e.Type.Equals("AuthorizationToken")).SingleOrDefault();
var token = tokenEntity?.Properties?.Value <string>("token");
if (token != null)
{
var jwt = new JwtSecurityToken(token);
var log = string.Join(" | ", jwt.Payload.Claims.ToArray().Select(c => c.Type + ":" + c.Value).ToArray());
Trace.TraceInformation("[Token]" + log);
}
}
catch (Exception exp)
{
Trace.TraceError($"[Exception]{exp.ToString()}");
}
finally
{
}
try
{
Trace.TraceInformation($"[{activity.From.Id}] to [{activity.Recipient.Id}]:{activity.AsMessageActivity().Text ?? JsonConvert.SerializeObject(activity.AsMessageActivity().Attachments)}");
LogAppInsightsEvent((Microsoft.Bot.Connector.Activity)activity);
}
catch (Exception e)
{
Trace.TraceError($"[Exception]Unable to Log AppInsights Event:{e.Message}");
}
}
public async Task LogAsync(IActivity activity)
{
Debug.WriteLine($"From:{activity.From.Id} - To:{activity.Recipient.Id} - Message:{activity.AsMessageActivity()?.Text}");
var message = $"**{activity.From.Name}**: {activity.AsMessageActivity()?.Text}";
ChatContainer.Add(message);
}
protected override async Task SendActivityImplementation(IBotContext context, IActivity activity)
{
switch (activity.Type)
{
case ActivityTypes.Message:
{
IMessageActivity message = activity.AsMessageActivity();
if (message.Attachments != null && message.Attachments.Any())
{
var attachment = message.Attachments.Count == 1 ? "1 attachments" : $"{message.Attachments.Count()} attachments";
Console.WriteLine($"{message.Text} with {attachment} ");
}
else
{
Console.WriteLine($"{message.Text}");
}
}
break;
case ActivityTypesEx.Delay:
{
// The Activity Schema doesn't have a delay type build in, so it's simulated
// here in the Bot. This matches the behavior in the Node connector.
int delayMs = (int)((Activity)activity).Value;
await Task.Delay(delayMs).ConfigureAwait(false);
}
break;
default:
Console.WriteLine("Bot: activity type: {0}", activity.Type);
break;
}
}
/// <summary>
/// Assert that the reply is expected activity
/// </summary>
/// <param name="expected"></param>
/// <param name="description"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public TestFlow AssertReply(IActivity expected, [CallerMemberName] string description = null, UInt32 timeout = 3000)
{
return AssertReply((reply) =>
{
if (expected.Type != reply.Type)
throw new Exception($"{description}: Type should match");
if (expected.AsMessageActivity().Text != reply.AsMessageActivity().Text)
{
if (description == null)
throw new Exception($"Expected:{expected.AsMessageActivity().Text}\nReceived:{reply.AsMessageActivity().Text}");
else
throw new Exception($"{description}: Text should match");
}
// TODO, expand this to do all properties set on expected
}, description, timeout);
}
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 LogAsync(IActivity activity)
{
// apply a filter
if (!((Microsoft.Bot.Connector.Activity)activity).Text.ToLower().Contains("bot"))
{
// log to output as before
Debug.WriteLine($"From:{activity.From.Id} - To:{activity.Recipient.Id} " +
$"- Message:{activity.AsMessageActivity().Text}");
// log also to a file
tw.WriteLine($"From:{activity.From.Id} - To:{activity.Recipient.Id} " +
$"- Message:{activity.AsMessageActivity().Text}", true);
}
// save changes by clearing the buffer but keep the buffer open
tw.Flush();
}
private static IMessageActivity CreateActivity(IActivity activity)
{
if (activity.Type != ActivityTypes.Message)
{
throw new ArgumentException("Provided Activity must be a Message Activity");
}
return(activity.AsMessageActivity());
}
public Task LogActivityAsync(IActivity activity)
{
if (activity.Type == ActivityTypes.Message)
{
Console.WriteLine(activity.AsMessageActivity().Text);
}
return(Task.CompletedTask);
}
public void GIVENAnyActivity_WHENActivityAdapterIsInvoked_THENActivityIsMapped(IActivity activity)
{
// Arrange
var adapter = new ActivityAdapter(activity);
var time = JsonConvert.SerializeObject(activity.Timestamp?.ToUniversalTime());
time = time.Substring(1, time.Length - 2);
// Act
// Assert
Assert.Equal(adapter.TimeStampIso8601, time);
Assert.Equal(adapter.Type, activity.Type);
Assert.Equal(adapter.ChannelId, activity.ChannelId);
Assert.Equal(adapter.ReplyToId, activity.ReplyToId);
Assert.Equal(adapter.MessageActivity.Text, activity.AsMessageActivity().Text);
Assert.Equal(adapter.MessageActivity.Id, activity.AsMessageActivity().Id);
Assert.Equal(adapter.ChannelAccount.Name, activity.From.Name);
Assert.Equal(adapter.ChannelAccount.Id, activity.From.Id);
}
public async Task LogActivityAsync(IActivity activity)
{
// activity only contains Text if this is a message
var isMessage = activity.AsMessageActivity() != null ? true : false;
if (isMessage)
{
// Customize this to save whatever data you want
var data = new
{
From = activity.From,
To = activity.Recipient,
Text = activity.AsMessageActivity().Text,
};
var document = new Dictionary<string, object>();
// activity.Id is being used as the Cosmos Document Id
document.Add(activity.Id, data);
await _storage.WriteAsync(document, new CancellationToken());
}
}
public async Task LogAsync(IActivity activity)
{
string fromId = activity.From.Id;
string toId = activity.Recipient.Id;
string message = activity.AsMessageActivity().Text;
string insertQuery = "INSERT INTO userChatLog(fromId, toId, message) VALUES (@fromId,@toId,@message)";
// Passing the fromId, toId, message to the the user chatlog table
SqlCommand command = new SqlCommand(insertQuery, connection);
command.Parameters.AddWithValue("@fromId", fromId);
command.Parameters.AddWithValue("@toId", toId);
command.Parameters.AddWithValue("@message", message);
// Insert to Azure sql database
command.ExecuteNonQuery();
Debug.WriteLine("Insertion successful of message: " + activity.AsMessageActivity().Text);
}
public MessageAssertions(IActivity activity, BotSpecSettings settings) : base(activity, settings)
{
var message = activity.AsMessageActivity();
if (message == null)
{
throw new BotSpecException($"Could not convert activity to a message. This activity is a {activity.Type}.");
}
_message = message;
_settings = settings;
}
public async Task LogAsync(IActivity activity)
{
IMessageActivity a = activity.AsMessageActivity();
//loop through for cases there are multiple attachments
for (int i = 0; i < a.Attachments.Count; i++)
{
//in the case of herocard
if (a.Attachments[i].ContentType == "application/vnd.microsoft.card.hero")
{
//log something, i randomly picked a property
Debug.WriteLine(a.Attachments[i].Name);
}
//another case
if (a.Attachments[i].ContentType.Contains("image"))
{
//Maybe save the image somewhere
}
}
Debug.WriteLine(activity.AsMessageActivity()?.Text);
}
private static void VerifyIntentRequest(SkillRequest skillRequest, IActivity activity, AlexaRequestMapperOptions mapperOptions)
{
VerifyRequest(skillRequest, activity, mapperOptions);
var messageActivity = activity.AsMessageActivity();
Assert.NotNull(messageActivity);
Assert.Equal(DeliveryModes.ExpectReplies, messageActivity.DeliveryMode);
Assert.Equal(skillRequest.Request.Locale, messageActivity.Locale);
Assert.Equal(((IntentRequest)skillRequest.Request).Intent.Slots[mapperOptions.DefaultIntentSlotName].Value, messageActivity.Text);
}
public async Task LogAsync(IActivity activity)
{
var message = activity.AsMessageActivity();
if (message != null && message.From.Name.Equals(WebConfigurationManager.AppSettings["BotId"]) && message.Attachments.Count > 0)
{
var jsonAttachments = JsonConvert.SerializeObject(message.Attachments, Formatting.Indented);
// we access and update the received instance cause if get/save from bot state,
// the ETag changes and saving this cached instance later fails (with this we are using the loaded data)
this.botData.PrivateConversationData.SetValue(Constants.LastJsonKey, jsonAttachments);
}
}
protected override async Task PostAsync(IActivity item, bool state, CancellationToken token)
{
var message = item.AsMessageActivity();
if (message != null)
{
var helpDialog = dialogFactory.CreateHelpDialog();
var interruption = helpDialog.Void <object, IMessageActivity>();
task.Call(interruption, null);
await task.PollAsync(token);
}
}
/// <summary>
/// Assert that the reply is expected activity
/// </summary>
/// <param name="expected"></param>
/// <param name="description"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public TestFlow AssertReply(IActivity expected, string description = null, UInt32 timeout = 3000)
{
return(this.AssertReply((reply) =>
{
if (expected.Type != reply.Type)
{
throw new Exception($"{description}: Type should match");
}
if (expected.AsMessageActivity().Text != reply.AsMessageActivity().Text)
{
throw new Exception($"{description}: Text should match");
}
// TODO, expand this to do all properties set on expected
}, description, timeout));
}
/// <summary>
/// Adds an assertion that the turn processing logic responds as expected.
/// </summary>
/// <param name="expected">The expected activity from the bot.</param>
/// <param name="equalityComparer">The equality parameter which compares two activities.</param>
/// <param name="description">A message to send if the actual response is not as expected.</param>
/// <param name="timeout">The amount of time in milliseconds within which a response is expected.</param>
/// <returns>A new <see cref="TestFlow"/> object that appends this assertion to the modeled exchange.</returns>
/// <remarks>This method does not modify the original <see cref="TestFlow"/> object.</remarks>
/// <exception cref="Exception">The bot did not respond as expected.</exception>
public TestFlow AssertReply(IActivity expected, IEqualityComparer <IActivity> equalityComparer, [CallerMemberName] string description = null, uint timeout = 3000)
{
return(AssertReply(
(reply) =>
{
description = description ?? expected.AsMessageActivity()?.Text.Trim();
if (expected.Type != reply.Type)
{
throw new Exception($"{description}: Type should match");
}
if (equalityComparer != null)
{
if (!equalityComparer.Equals(expected, reply))
{
throw new Exception($"Expected:{expected}\nReceived:{reply}");
}
}
else
{
if (expected.AsMessageActivity().Text.Trim() != reply.AsMessageActivity().Text.Trim())
{
if (description == null)
{
throw new Exception($"Expected:{expected.AsMessageActivity().Text}\nReceived:{reply.AsMessageActivity().Text}");
}
else
{
throw new Exception($"{description}:\nExpected:{expected.AsMessageActivity().Text}\nReceived:{reply.AsMessageActivity().Text}");
}
}
}
},
description,
timeout));
}
Task IActivityLogger.LogAsync(IActivity activity)
{
IMessageActivity msg = activity.AsMessageActivity();
using (ContosoData.ContosoDataContext dataContext = new ContosoData.ContosoDataContext())
{
var newActivity = Mapper.Map <IMessageActivity, Activity>(msg);
if (string.IsNullOrEmpty(newActivity.Id))
{
newActivity.Id = Guid.NewGuid().ToString();
}
dataContext.ActivityLogs.Add(newActivity);
dataContext.SaveChanges();
}
return(Task.CompletedTask);
}
public async Task Context_ReplyActivity()
{
TestAdapter adapter = new TestAdapter();
await new TestFlow(adapter, async(context) =>
{
if (context.Request.AsMessageActivity().Text == "hello")
{
IActivity reply = context.ConversationReference.GetPostToUserMessage();
reply.AsMessageActivity().Text = "world";
context.Reply(reply);
}
})
.Send("hello")
.AssertReply("world", "send/reply with Activity works")
.StartTest();
}
/// <summary>
/// Helper method to track the sentiment of incoming messages.
/// </summary>
private static async Task TrackMessageSentiment(IActivity activity)
{
var text = activity.AsMessageActivity().Text;
var numWords = text.Split(' ').Length;
if (numWords >= _textAnalyticsMinLength && !string.IsNullOrEmpty(_textAnalyticsApiKey))
{
var properties = new Dictionary <string, string>
{
{ "score", (await GetSentimentScore(text)).ToString(CultureInfo.InvariantCulture) }
};
var et = BuildEventTelemetry(activity, properties);
et.Name = TelemetryEventTypes.MessageSentiment;
TelemetryClient.TrackEvent(et);
}
}
public async Task LogAsync(IActivity activity)
{
Debug.WriteLine($"From:{activity.From.Id} - To:{activity.Recipient.Id} - Message:{activity.AsMessageActivity()?.Text}");
try
{
//string dir = Directory.GetCurrentDirectory();
string dir = System.AppDomain.CurrentDomain.BaseDirectory;
XmlDocument doc = new XmlDocument();
doc.Load(dir + "/Conversations.xml");
XmlNode root = doc.SelectSingleNode("Conversations");
XmlNode newNode = doc.CreateNode(XmlNodeType.Element, "Message", null);
XmlNode textNode = doc.CreateNode(XmlNodeType.Element, "Text", null);
textNode.InnerText = activity.AsMessageActivity()?.Text;
XmlNode fromNode = doc.CreateNode(XmlNodeType.Element, "From", null);
XmlNode fromIdNode = doc.CreateNode(XmlNodeType.Element, "ID", null);
fromIdNode.InnerText = activity.From.Id.ToString();
XmlNode fromNameNode = doc.CreateNode(XmlNodeType.Element, "Name", null);
fromNameNode.InnerText = activity.From.Name.ToString();
fromNode.AppendChild(fromIdNode);
fromNode.AppendChild(fromNameNode);
XmlNode toNode = doc.CreateNode(XmlNodeType.Element, "To", null);
XmlNode toIdNode = doc.CreateNode(XmlNodeType.Element, "ID", null);
toIdNode.InnerText = activity.Recipient.Id.ToString();
XmlNode toNameNode = doc.CreateNode(XmlNodeType.Element, "Name", null);
toNameNode.InnerText = activity.Recipient.Name.ToString();
toNode.AppendChild(toIdNode);
toNode.AppendChild(toNameNode);
XmlNode timestampNode = doc.CreateNode(XmlNodeType.Element, "TimeStamp", null);
timestampNode.InnerText = DateTime.Now.ToString();
XmlNode convIdNode = doc.CreateNode(XmlNodeType.Element, "ConversationId", null);
convIdNode.InnerText = activity.Conversation.Id.ToString();
XmlNode serviceUrlNode = doc.CreateNode(XmlNodeType.Element, "ServiceUrl", null);
serviceUrlNode.InnerText = activity.ServiceUrl.ToString();
newNode.AppendChild(timestampNode);
newNode.AppendChild(convIdNode);
newNode.AppendChild(fromNode);
newNode.AppendChild(toNode);
newNode.AppendChild(textNode);
newNode.AppendChild(serviceUrlNode);
root.AppendChild(newNode);
doc.Save(dir + "/Conversations.xml");
}
catch (Exception e)
{
}
}
/// <summary>
/// Logs a single Activity message
/// </summary>
/// <param name="activity">An activity to be logged</param>
/// <returns></returns>
/// <exception cref="ArgumentException">thrown when message exceeds length limit</exception>
public async Task LogAsync(IActivity activity)
{
var message = activity.AsMessageActivity();
string jsonMsg = JsonConvert.SerializeObject(message, _jsonSerializerSettings);
var bytes = GetBytes(jsonMsg);
if (_queueLoggerSettings.OverflowHanding == LargeMessageMode.Discard)
{
//if fails do not do anything....
try
{
await _client.SendAsync(new BrokeredMessage(bytes));
}
catch
{
// ignored
}
}
else if (_queueLoggerSettings.OverflowHanding == LargeMessageMode.Error)
{
//let it fail
await _client.SendAsync(new BrokeredMessage(bytes));
}
else if (_queueLoggerSettings.OverflowHanding == LargeMessageMode.Trim)
{
do
{
try
{
await _client.SendAsync(new BrokeredMessage(bytes));
return;
}
catch
{
//cut off some of the text to fit
message.Text = message.Text.Substring(0, (int)(message.Text.Length * _cutCoefficient));
jsonMsg = JsonConvert.SerializeObject(message, _jsonSerializerSettings);
bytes = GetBytes(jsonMsg);
}
} while (true);
}
}