/// <summary>
/// Adds a row to current Log file.
/// </summary>
/// <param name="columns">Columns to write on row.</param>
/// <param name="separator">Column separator.</param>
public void AddRow(string[] columns, string separator = " ")
{
var row = new StringBuilder();
row.Append(DateTime.UtcNow);
foreach (string column in columns)
{
row.Append(separator);
row.Append(column);
}
if (Async)
{
ActiveQueue.Enqueue(row.ToString());
if (!Writing)
{
StartTask();
}
}
else
{
CheckIfNewFileNeeded();
TryWrite(CurrentLogFile, row.ToString());
}
}
public async override Task <ResourceResponse[]> SendActivities(ITurnContext context, Activity[] activities)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (activities == null)
{
throw new ArgumentNullException(nameof(activities));
}
if (activities.Length == 0)
{
throw new ArgumentException("Expecting one or more activities, but the array was empty.", nameof(activities));
}
var responses = new ResourceResponse[activities.Length];
// NOTE: we're using for here (vs. foreach) because we want to simultaneously index into the
// activities array to get the activity to process as well as use that index to assign
// the response to the responses array and this is the most cost effective way to do that.
for (var index = 0; index < activities.Length; index++)
{
var activity = activities[index];
if (String.IsNullOrEmpty(activity.Id))
{
activity.Id = Guid.NewGuid().ToString("n");
}
if (activity.Timestamp == null)
{
activity.Timestamp = DateTime.UtcNow;
}
if (activity.Type == ActivityTypesEx.Delay)
{
// The BotFrameworkAdapter and Console adapter implement this
// hack directly in the POST method. Replicating that here
// to keep the behavior as close as possible to facillitate
// more realistic tests.
int delayMs = (int)activity.Value;
await Task.Delay(delayMs);
}
else
{
lock (_activeQueueLock)
{
ActiveQueue.Enqueue(activity);
}
}
responses[index] = new ResourceResponse(activity.Id);
}
return(responses);
}
/// <summary>
/// Called by TestFlow to check next reply
/// </summary>
/// <returns></returns>
public IActivity GetNextReply()
{
lock (_activeQueueLock)
{
if (ActiveQueue.Count > 0)
{
return(ActiveQueue.Dequeue());
}
}
return(null);
}
/// <summary>
/// Creates a new conversation on the specified channel.
/// </summary>
/// <param name="channelId">The ID of the channel.</param>
/// <param name="callback">The bot logic to call when the conversation is created.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A task that represents the work queued to execute.</returns>
/// <remarks>This resets the <see cref="ActiveQueue"/>, and does not maintain multiple converstion queues.</remarks>
public Task CreateConversationAsync(string channelId, BotCallbackHandler callback, CancellationToken cancellationToken)
{
ActiveQueue.Clear();
var update = Activity.CreateConversationUpdateActivity();
update.Conversation = new ConversationAccount()
{
Id = Guid.NewGuid().ToString("n")
};
var context = new TurnContext(this, (Activity)update);
return(callback(context, cancellationToken));
}
/// <summary>
/// NOTE: this resets the queue, it doesn't actually maintain multiple converstion queues
/// </summary>
/// <param name="channelId"></param>
/// <param name="callback"></param>
/// <returns></returns>
//public override Task CreateConversation(string channelId, Func<ITurnContext, Task> callback)
public Task CreateConversation(string channelId, Func <ITurnContext, Task> callback)
{
ActiveQueue.Clear();
var update = Activity.CreateConversationUpdateActivity();
update.Conversation = new ConversationAccount()
{
Id = Guid.NewGuid().ToString("n")
};
var context = new TurnContext(this, (Activity)update);
return(callback(context));
}
private void Enqueue(Activity activity)
{
lock (_activeQueueLock)
{
// if there are pending requests, fulfill them with the activity.
while (_queuedRequests.Any())
{
var tcs = _queuedRequests.Dequeue();
if (tcs.Task.IsCanceled == false)
{
tcs.SetResult(activity);
return;
}
}
// else we enqueue for next requester
ActiveQueue.Enqueue(activity);
}
}
public override Task DeleteActivity(ITurnContext context, ConversationReference reference)
{
lock (_activeQueueLock)
{
var replies = ActiveQueue.ToList();
for (int i = 0; i < ActiveQueue.Count; i++)
{
if (replies[i].Id == reference.ActivityId)
{
replies.RemoveAt(i);
ActiveQueue.Clear();
foreach (var item in replies)
{
ActiveQueue.Enqueue(item);
}
break;
}
}
}
return(Task.CompletedTask);
}
public override Task <ResourceResponse> UpdateActivity(ITurnContext context, Activity activity)
{
lock (_activeQueueLock)
{
var replies = ActiveQueue.ToList();
for (int i = 0; i < ActiveQueue.Count; i++)
{
if (replies[i].Id == activity.Id)
{
replies[i] = activity;
ActiveQueue.Clear();
foreach (var item in replies)
{
ActiveQueue.Enqueue(item);
}
return(Task.FromResult(new ResourceResponse(activity.Id)));
}
}
}
return(Task.FromResult(new ResourceResponse()));
}
