public static void ReceiveActivities(ActivitySet activitySet)
{
if (activitySet != null)
{
foreach (var a in activitySet.Activities)
{
if (a.Type == ActivityTypes.Message && a.From.Id.ToLowerInvariant().Contains("bot"))
{
Console.WriteLine($"<Bot>: {a.Text}");
if (a.Attachments.Any())
{
foreach (var attachment in a.Attachments)
{
var stream = attachment.Content as Stream;
Task.Run(async() => {
int count;
int total = 0;
byte[] buffer = new byte[4096];
do
{
count = await stream.ReadAsync(buffer, 0, 4096);
total += count;
} while (count > 0);
Console.WriteLine($" Read stream of length: {total}");
});
}
}
}
}
}
}
private async void Connection_OnMessage(string obj)
{
if (string.IsNullOrWhiteSpace(obj))
{
return;
}
ActivitySet activitySet = JsonConvert.DeserializeObject <ActivitySet>(obj);
foreach (var activity in activitySet.Activities)
{
if (activity.From.Id == "Jean")
{
continue;
}
switch (activity.Text)
{
case "take picture":
await TakePicture(activity.ChannelData.ToString());
return;
case "registered":
return;
default:
HandleActivity(activity);
return;
}
}
}
/// <summary>
/// Gets the latest activity set of the current conversation.
/// </summary>
/// <returns>The latest activity set or null, if no conversation or no activities since the last time we checked.</returns>
private async Task <ActivitySet> GetActivitySetAsync()
{
ActivitySet activitySet = null;
if (_conversation != null)
{
using (DirectLineClient directLineClient = new DirectLineClient(_botSecret))
{
directLineClient.Conversations.ReconnectToConversation(_conversation.ConversationId);
if (string.IsNullOrEmpty(_watermark))
{
activitySet = await directLineClient.Conversations.GetActivitiesAsync(_conversation.ConversationId);
}
else
{
activitySet = await directLineClient.Conversations.GetActivitiesAsync(_conversation.ConversationId, _watermark);
}
}
if (activitySet != null)
{
_watermark = activitySet.Watermark;
}
}
return(activitySet);
}
/// <summary>
/// Use directlineClient to get bot response
/// </summary>
/// <returns>List of DirectLine activities</returns>
/// <param name="directLineClient">directline client</param>
/// <param name="conversationtId">current conversation ID</param>
/// <param name="botName">name of bot to connect to</param>
private static async Task <List <Activity> > GetBotResponseActivitiesAsync(DirectLineClient directLineClient, string conversationtId)
{
ActivitySet response = null;
List <Activity> result = new List <Activity>();
do
{
response = await directLineClient.Conversations.GetActivitiesAsync(conversationtId, _watermark);
if (response == null)
{
// response can be null if directLineClient token expires
Console.WriteLine("Conversation expired. Press any key to exit.");
Console.Read();
directLineClient.Dispose();
Environment.Exit(0);
}
_watermark = response?.Watermark;
result = response?.Activities?.Where(x =>
x.Type == ActivityTypes.Message &&
string.Equals(x.From.Name, s_botService.BotName, StringComparison.Ordinal)).ToList();
if (result != null && result.Any())
{
return(result);
}
Thread.Sleep(1000);
} while (response != null && response.Activities.Any());
return(new List <Activity>());
}
/// <summary>
/// Gets the latest reply (Activity) from the bot.
/// </summary>
/// <returns>The latest Activity instance or null, if none available.</returns>
public async Task <Activity> GetLatestReplyAsync()
{
ActivitySet activitySet = await GetActivitySetAsync();
Activity activity = null;
if (activitySet != null &&
activitySet.Activities != null &&
activitySet.Activities.Count > 0)
{
#if DEBUG
for (int i = 0; i < activitySet.Activities.Count; ++i)
{
Activity a = activitySet.Activities[i];
if (a != null)
{
System.Diagnostics.Debug.WriteLine($"GetLatestReplyAsync: Activity {(i + 1)}: Text: \"{a.Text}\" ChannelData: \"{a.ChannelData}\"");
}
}
#endif
activity = activitySet.Activities[activitySet.Activities.Count - 1];
}
return(activity);
}
private async Task RespondPowerVirtualAgentsBotReplyAsync(DirectLineClient client, RelayConversation currentConversation, ITurnContext <IMessageActivity> turnContext)
{
var retryMax = WaitForBotResponseMaxMilSec / PollForBotResponseIntervalMilSec;
for (int retry = 0; retry < retryMax; retry++)
{
// Get bot response using directlineClient,
// response contains whole conversation history including user & bot's message
ActivitySet response = await client.Conversations.GetActivitiesAsync(currentConversation.ConversationtId, currentConversation.WaterMark);
// Filter bot's reply message from response
List <DirectLineActivity> botResponses = response?.Activities?.Where(x =>
x.Type == DirectLineActivityTypes.Message &&
string.Equals(x.From.Name, _botService.GetBotName(), StringComparison.Ordinal)).ToList();
if (botResponses?.Count() > 0)
{
if (int.Parse(response?.Watermark ?? "0") <= int.Parse(currentConversation.WaterMark ?? "0"))
{
// means user sends new message, should break previous response poll
return;
}
currentConversation.WaterMark = response.Watermark;
await turnContext.SendActivitiesAsync(_responseConverter.ConvertToBotSchemaActivities(botResponses).ToArray());
}
Thread.Sleep(PollForBotResponseIntervalMilSec);
}
}
private async void PublishActivities(ActivitySet set)
{
//Debug.Log($"[BOT] Received activity set [{set.Activities.Count}]");
foreach (var activity in set.Activities)
{
if (activity.Type == "message")
{
if (OnlyBotMessages && activity.From?.Id == Account.Id)
{
continue;
}
UnityMainThreadDispatcher.Instance().Enqueue(() => MessageReceived.Invoke(activity));
float messageDelta = (float)DateTime.Now.Subtract(m_LastTime).TotalSeconds;
m_LastTime = DateTime.Now;
if (messageDelta < messageDelay)
{
await Task.Delay(TimeSpan.FromSeconds(messageDelay - messageDelta));
}
}
else
{
UnityMainThreadDispatcher.Instance().Enqueue(() => SystemActivityReceived.Invoke(activity));
}
}
}
/// <summary>
/// Polls for new messages (activities).
/// </summary>
/// <param name="conversationId">
/// The ID of the conversation.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task PollMessagesAsync(string conversationId = null)
{
if (!string.IsNullOrEmpty(conversationId) || !string.IsNullOrEmpty(this.ConversationId))
{
conversationId = string.IsNullOrEmpty(conversationId) ? this.ConversationId : conversationId;
ActivitySet activitySet = null;
using (var directLineClient = new DirectLineClient(this.DirectLineSecret))
{
directLineClient.Conversations.ReconnectToConversation(conversationId);
activitySet = await directLineClient.Conversations.GetActivitiesAsync(conversationId, this.watermark);
}
if (activitySet != null)
{
this.watermark = activitySet.Watermark;
var activities = (from activity in activitySet.Activities select activity).ToList();
if (this.synchronizationContext != null)
{
this.synchronizationContext.Post((o) => this.ActivitiesReceived?.Invoke(this, activities), null);
}
else
{
this.ActivitiesReceived?.Invoke(this, activities);
}
}
}
}
public async Task <IActionResult> Index()
{
try
{
var tokenClient = new DirectLineClient(new Uri("https://directline.botframework.com/"), new DirectLineClientCredentials("H-mIGKOIXJ8.M0P2_afqawnF1Yzbur8kVYgkrbaGtcoSnjP1nv11NZU"));
tokenClient.Tokens.GenerateTokenForNewConversation();
Conversation _conversation = await tokenClient.Conversations.StartConversationAsync().ConfigureAwait(false);
var user = new ChannelAccount()
{
Id = "123", Name = "Fred"
};
var response = await tokenClient.Conversations.PostActivityAsync(_conversation.ConversationId,
new Activity()
{
Type = "message",
Text = "Hello",
From = user
}).ConfigureAwait(false);
ActivitySet activites = await tokenClient.Conversations.GetActivitiesAsync(_conversation.ConversationId);
this.ReceiveActivities(activites);
return(View());
}
catch (Exception)
{
return(NotFound());
}
}
private async Task <List <Microsoft.Bot.Connector.DirectLine.Activity> > GetActivitiesAsync(DirectLineClient directLineClient, string conversationtId, string botName)
{
ActivitySet response = null;
List <Microsoft.Bot.Connector.DirectLine.Activity> result = new List <Microsoft.Bot.Connector.DirectLine.Activity>();
string watermark = null;
do
{
response = await directLineClient.Conversations.GetActivitiesAsync(conversationtId, watermark);
watermark = response.Watermark;
result = response?.Activities?.Where(x =>
x.Type == Microsoft.Bot.Connector.DirectLine.ActivityTypes.Message &&
string.Equals(x.From.Name, botName, StringComparison.Ordinal)).ToList();
if (result != null && result.Any())
{
return(result);
}
Thread.Sleep(1000);
} while (response.Activities.Any());
return(result);
}
public static async Task <ActivitySet> ReadBotMessagesAsync(string conversationId, string watermark, ILogger log)
{
try
{
log.LogInformation("Reading FROM bot messages");
ActivitySet activitySet = await client.Conversations.GetActivitiesAsync(conversationId, watermark);
activitySet.Activities = (from x in activitySet.Activities
where x.From.Id == botId
select x).ToList();
foreach (Activity activity in activitySet.Activities)
{
log.LogInformation("BotMessage: " + activity.Text);
}
return(activitySet);
}
catch (Exception ex)
{
log.LogError("Exception occurred in ReadBotMessagesAsync: {1}", ex);
throw;
}
}
private ActivitySet GetActivitiesWithRetry(int expectedNumberOfActivities, string watermark)
{
var noOfRetries = _settings.RetryTimes;
ActivitySet activitySet = null;
var retry = true;
while (noOfRetries > 0 && retry)
{
_logger.LogDebug($"Getting latest activity set. Will try {noOfRetries} times.");
var latestSet = GetActivitySet(watermark);
var newActivities = NumberOfNewActivities(latestSet, watermark);
_logger.LogDebug($"{newActivities} new activities since last retrieval");
if (expectedNumberOfActivities > 0 && newActivities < expectedNumberOfActivities)
{
_logger.LogDebug($@"Expected {expectedNumberOfActivities} but found {newActivities}.
Waiting {_settings.RetryWaitTimeMilliseconds}ms for new activities");
noOfRetries--;
Task.Delay(_settings.RetryWaitTimeMilliseconds).Wait();
continue;
}
activitySet = latestSet;
retry = false;
}
return(activitySet);
}
public override async Task StartListening(CancellationToken cancellationToken = default(CancellationToken))
{
this.IsListening = true;
string watermark = (await this.DirectLineConversationService.GetUserConversationInfoAsync(this.UserId, cancellationToken)).Watermark;
this.MessengerInitialized.Set();
while (this.IsListening)
{
var conversationInfo = await this.DirectLineConversationService.GetUserConversationInfoAsync(this.UserId, cancellationToken);
var conversationId = conversationInfo.ConversationId;
var httpResponse = await this.DirectLineConversationService.GetActivitiesWithHttp(conversationId, watermark, cancellationToken);
ActivitySet responseBody = httpResponse.Body;
var allNewMessages = responseBody.Activities;
var incomingNewMessages = allNewMessages.Where(m => m.From.Id != this.UserId).ToList();
watermark = responseBody.Watermark;
await this.DirectLineConversationService.SetUserConversationWatermark(this.UserId, watermark);
HttpUserBotMessenger.Logger.Trace($"[{this.UserId}]\tincoming messages: {incomingNewMessages.Count}");
this.OnBotToUserMessagesReceived(new BotToUserMessagesEventArgs(incomingNewMessages));
Thread.Sleep(1000);
}
}
private async Task <IList <Activity> > AllMessagesSinceWatermark(string specificWatermark = null)
{
specificWatermark = string.IsNullOrEmpty(specificWatermark) ? watermark : specificWatermark;
ActivitySet messageSet = await directLineClient.Conversations.GetActivitiesAsync(conversation.ConversationId, specificWatermark);
watermark = messageSet?.Watermark;
return(messageSet.Activities);
}
private static int NumberOfNewActivities(ActivitySet activitySet, string watermark)
{
if (activitySet?.Watermark == null)
{
return(0);
}
return(int.Parse(activitySet.Watermark ?? "0") - int.Parse(watermark ?? "0"));
}
public async Task SendMessage(string user, string message)
{
string accessToken = await Context.GetHttpContext().GetTokenAsync("access_token");
// Préparation de l'appel à l'API
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Récurération des données et convertion des données dans le bon type
string content = await client.GetStringAsync(_configuration["URLAPI"] + "api/Insults");
string content1 = await client.GetStringAsync(_configuration["URLAPI"] + "api/account/getUserInfo");
string content2 = await client.GetStringAsync(_configuration["URLAPI"] + "api/Data/BotCommands");
List <BotCommand> botCommands = JsonConvert.DeserializeObject <List <BotCommand> >(content2);
AspNetUser user1 = JsonConvert.DeserializeObject <AspNetUser>(content1);
var httpContent = new StringContent("test", Encoding.UTF8, "application/json");
var response = await UserHandler.tokenClient.Conversations.PostActivityAsync(UserHandler.ConversationId,
new Activity()
{
Type = "message",
Text = message,
From = UserHandler.channelAccount.Where(x => x.Name.Equals(user1.UserName)).FirstOrDefault(),
}).ConfigureAwait(false);
ActivitySet activites = await UserHandler.tokenClient.Conversations.GetActivitiesAsync(UserHandler.ConversationId);
List <Insult> insults = JsonConvert.DeserializeObject <List <Insult> >(content);
List <string> words = insults.Select(i => i.InsultName).ToList();
ProfanityFilter.ProfanityFilter filter = new ProfanityFilter.ProfanityFilter();
filter.AddProfanity(words);
//string censored =
string censored = filter.CensorString(ReceiveActivities(activites, user1.UserName));
await Clients.All.SendAsync("ReceiveMessage", user, censored);
ActivitySet botActivites = await UserHandler.tokenClient.Conversations.GetActivitiesAsync(UserHandler.ConversationId);
string bot = null;
if (message.Contains("/giphy"))
{
bot = ReceiveBotActivities(botActivites, "lovemirroring-bot");
await Clients.All.SendAsync("ImageReceive", "bot", bot);
}
else
{
bot = ReceiveBotActivities(botActivites, "lovemirroring-bot");
await Clients.All.SendAsync("ReceiveMessage", "bot", bot);
}
}
private void Bot_OnNewMessage(ActivitySet args)
{
foreach (var activity in args.activities)
{
if (!activity.from.id.Equals(clientId))
{
if (activity.text.Length > 0)
{
Device.BeginInvokeOnMainThread(() =>
{
stack.Children.Insert(0, (new BotTextMessage()
{
TextMessage = activity.text
}));
});
}
if (activity.attachments.Count > 0)
{
foreach (var att in activity.attachments)
{
if (att.contentType.Equals("application/vnd.microsoft.card.hero"))
{
var card = ((JObject)att.content).ToObject <HeroCard>();
if ((card.buttons != null) && (card.buttons.Count > 0))
{
Device.BeginInvokeOnMainThread(() =>
{
var message = new ConfirmationMessage()
{
TextMessage = card.text, Buttons = card.buttons
};
message.ButtonClicked += Message_ButtonClicked;
stack.Children.Insert(0, (message));
}
);
}
else
{
Device.BeginInvokeOnMainThread(() =>
{
var message = new MapMessage()
{
TitleMessage = card.title, SubtitleMessage = card.subtitle, TextMessage = card.text, ImageUrl = card.images[0].url
};
stack.Children.Insert(0, message);
}
);
}
}
}
}
}
}
}
public static async Task SendActivitySetAsync(this IDirectLineConnectionManager mgr, string conversationId, Activity activity)
{
var activitySet = new ActivitySet {
Activities = new List <Activity>()
{
activity,
},
Watermark = 0,
};
var message = JsonConvert.SerializeObject(activitySet);
// notify the client
await mgr.SendAsync(conversationId, message);
}
public void ReceiveActivities(ActivitySet activitySet)
{
if (activitySet != null)
{
foreach (var a in activitySet.Activities)
{
if (a.Type == Microsoft.Bot.Connector.DirectLine.ActivityTypes.Message && a.From.Id.Contains("bot"))
{
_logger.LogInformation($"<Bot>: {a.Text}");
}
}
}
}
public static async Task RetrieveMessagesAsync(
Conversation conversation, CancellationTokenSource cancelSource)
{
const int ReceiveChunkSize = 1024;
var webSocket = new ClientWebSocket();
await webSocket.ConnectAsync(
new Uri(conversation.StreamUrl), cancelSource.Token);
var runTask = Task.Run(async() =>
{
try
{
while (webSocket.State == WebSocketState.Open)
{
var allBytes = new List <byte>();
var result = new WebSocketReceiveResult(0, WebSocketMessageType.Text, false);
byte[] buffer = new byte[ReceiveChunkSize];
while (!result.EndOfMessage)
{
result = await webSocket.ReceiveAsync(
new ArraySegment <byte>(buffer), cancelSource.Token);
allBytes.AddRange(buffer);
buffer = new byte[ReceiveChunkSize];
}
string message = Encoding.UTF8.GetString(allBytes.ToArray()).Trim();
ActivitySet activitySet = JsonConvert.DeserializeObject <ActivitySet>(message);
if (activitySet != null)
{
Message.Watermark = activitySet.Watermark;
}
List <Activity> activities;
if (CanDisplayMessage(message, activitySet, out activities))
{
Console.WriteLine();
activities.ForEach(activity => Console.WriteLine(activity.Text));
Message.WritePrompt();
}
}
}
catch (OperationCanceledException oce)
{
Console.WriteLine(oce.Message);
}
});
}
/// <summary>
/// Using the token for a specific discusion, make a post
/// </summary>
/// <param name="token"></param>
/// <param name="comment"></param>
/// <returns>(string)The response from the chatbot</returns>
public async Task <String> PostCommentByToken(string token, string comment)
{
Models.ChatbotDetails chatbot = await chatbotRepository.GetActiveBot();
// Get HttpClient
HttpClient httpClient = await GetHttpClient(token);
// Get active conversation
Conversation conversationinfo = await GetActiveConversation(token);
// Set the conversation url
string conversationUrl = chatbot.conversationUrlExtension + conversationinfo.ConversationId + chatbot.conversationUrlExtensionEnding;
// Create activity
Activity thisActivity = new Activity {
Type = "message", Text = comment, From = new ChannelAccount {
Id = "idToGoHere"
}
};
var myContent = JsonConvert.SerializeObject(thisActivity);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
// Post the activity
response = await httpClient.PostAsync(conversationUrl, byteContent);
if (response.IsSuccessStatusCode) // Yey -> It was posted
{
// Fetch messages
response = await httpClient.GetAsync(conversationUrl);
// set ActivitySet from the response
activitySet = response.Content.ReadAsAsync(typeof(ActivitySet)).Result as ActivitySet;
string responseString = null;
// For each activity in activitySet, get comment.
foreach (Activity a in activitySet.Activities)
{
responseString = a.Text;
}
// return the last comment in activitySet
return(responseString);
}
else
{
return(null);
}
}
public Task <ActivitySet> GetActivitySetAsync(string conversationId, int watermark)
{
var exists = _history.TryGetValue(conversationId, out var conversation);
if (!exists)
{
return(null);
}
var _activities = conversation?.Skip(watermark).ToList();
var count = _activities == null ? 0 : _activities.Count();
var result = new ActivitySet {
Activities = _activities ?? new List <Activity>(),
Watermark = watermark + count,
};
return(Task.FromResult(result));
}
/// <summary>
/// Polls for new messages (activities).
/// </summary>
/// <param name="conversationId">The ID of the conversation.</param>
/// <returns></returns>
public async Task PollMessagesAsync(string conversationId)
{
if (string.IsNullOrEmpty(conversationId))
{
return;
}
ActivitySet activitySet = null;
using (DirectLineClient directLineClient = new DirectLineClient(_directLineSecret))
{
var watermark = _conversationCache.GetConversation(new IdAndTimestamp(conversationId))?.ActivityWaterMark;
var conversation = directLineClient.Conversations.ReconnectToConversation(conversationId);
activitySet = await directLineClient.Conversations.GetActivitiesAsync(conversationId, watermark);
// XXX WarterMarkこの段階で処理してしまうのはちょっと嫌。
_conversationCache.PutConversation(
new IdAndTimestamp(conversationId),
new ConversationContext(conversation, activitySet?.Watermark));
}
if (activitySet != null)
{
Debug.WriteLine($"conversationId {conversationId} {activitySet.Activities?.Count} activity/activities received");
if (activitySet.Activities?.Count > 0)
{
Debug.WriteLine(JsonConvert.SerializeObject(activitySet.Activities));
}
// ボットへ送る方向のアクティビティは処理しない。
// TODO このDirectLineClientではその方向のアクティビティに ReplyToId を指定していないためそれでフィルタしているが、恐らく正しいフィルタではない。
var activities = activitySet.Activities
.Where(x => !string.IsNullOrEmpty(x.ReplyToId))
.ToList();
if (_synchronizationContext != null)
{
_synchronizationContext.Post((o) => ActivitiesReceived?.Invoke(this, activities), null);
}
else
{
ActivitiesReceived?.Invoke(this, activities);
}
}
}
private string ReadBotMessages(DirectLineClient client, string conversationId, string watermark)
{
ActivitySet messages = client.Conversations.GetActivities(conversationId, watermark);
watermark = messages?.Watermark;
var messagesFromBotText = from x in messages.Activities
where x.From.Id == botId
select x;
string response = "";
foreach (Activity activity in messagesFromBotText)
{
response = response + activity.Text + " ";
}
return(response);
}
private string ReceiveBotActivities(ActivitySet activitySet, string username)
{
List <Activity> list = new List <Activity>();
string text = "";
if (activitySet != null)
{
foreach (var a in activitySet.Activities)
{
if (a.Type == Microsoft.Bot.Connector.DirectLine.ActivityTypes.Message && a.From.Name.Contains(username))
{
list.Add(a);
}
}
}
text = list.Where(x => x.From.Name == username).OrderByDescending(f => f.Timestamp).First().Text;
return(text);
}
static bool CanDisplayMessage(string message, ActivitySet activitySet, out List <Activity> activities)
{
if (activitySet == null)
{
activities = new List <Activity>();
}
else
{
activities =
(from activity in activitySet.Activities
where activity.From.Id == Message.ChatbotID &&
!string.IsNullOrWhiteSpace(activity.Text)
select activity)
.ToList();
}
SuppressRepeatedActivities(activities);
return(!string.IsNullOrWhiteSpace(message) && activities.Any());
}
private void ProcessActivitySet(ActivitySet activitySet)
{
// lock the list while work with it.
lock (_listLock)
{
foreach (var dlActivity in activitySet.Activities)
{
// Convert the DL Activity object to a BF activity object.
var botActivity = JsonConvert.DeserializeObject <BotActivity>(JsonConvert.SerializeObject(dlActivity));
var activityIndex = int.Parse(botActivity.Id.Split('|')[1], CultureInfo.InvariantCulture);
if (activityIndex == _lastActivityIndex + 1)
{
ProcessActivity(botActivity, activityIndex);
_lastActivityIndex = activityIndex;
}
else
{
// Activities come out of sequence in some situations.
// put the activity in the future queue so we can process it once we fill in the gaps.
_futureQueue.Add(activityIndex, botActivity);
}
}
// Process the future queue and append the activities if we filled in the gaps.
var queueCopy = new KeyValuePair <int, BotActivity> [_futureQueue.Count];
_futureQueue.CopyTo(queueCopy, 0);
foreach (var kvp in queueCopy)
{
if (kvp.Key == _lastActivityIndex + 1)
{
ProcessActivity(kvp.Value, kvp.Key);
_futureQueue.Remove(kvp.Key);
_lastActivityIndex = kvp.Key;
}
else
{
break;
}
}
}
}
private async void SendMessageToBot(string message)
{
if (message.Length > 0)
{
listbox.Items.Add("自分 ： " + message);
listbox.UpdateLayout();
listbox.ScrollIntoView(listbox.Items.Last());
Activity userMessage = new Activity
{
From = new ChannelAccount(fromUser),
Text = message,
Type = ActivityTypes.Message
};
await client.Conversations.PostActivityAsync(conversation.ConversationId, userMessage);
try
{
ActivitySet activitySet = await client.Conversations.GetActivitiesAsync(conversation.ConversationId, null);
Activity activitie = activitySet.Activities.Last();
string response = activitie.Text;
listbox.Items.Add("Cortana： " + response);
listbox.UpdateLayout();
listbox.ScrollIntoView(listbox.Items.Last());
if (response.Length > 0)
{
TextToSpeech(response);
}
}
catch (Exception err)
{
var messageDialog = new Windows.UI.Popups.MessageDialog(err.Message, err.HResult.ToString());
await messageDialog.ShowAsync();
}
}
}
private async void SendMessage(string message)
{
string result = "对不起，无法回答您的问题";
if (await botService.SendMessage(message))
{
ActivitySet messages = await botService.GetMessages();
if (messages != null)
{
for (int i = 1; i < messages.activities.Length; i++)
{
result = messages.activities[i].text;
}
}
}
UnityEngine.WSA.Application.InvokeOnAppThread(() =>
{
TextToSpeech.Instance.SpeakText(result);
}, false);
}
/// <summary>
/// Polls for new messages (activities).
/// </summary>
/// <param name="conversationId">The ID of the conversation.</param>
/// <returns></returns>
public async Task PollMessagesAsync(string conversationId = null)
{
if (!string.IsNullOrEmpty(conversationId) || !string.IsNullOrEmpty(_conversation?.ConversationId))
{
conversationId = string.IsNullOrEmpty(conversationId) ? _conversation.ConversationId : conversationId;
ActivitySet activitySet = null;
using (DirectLineClient directLineClient = new DirectLineClient(_directLineSecret))
{
directLineClient.Conversations.ReconnectToConversation(conversationId);
activitySet = await directLineClient.Conversations.GetActivitiesAsync(conversationId, _watermark);
}
if (activitySet != null)
{
#if DEBUG
if (activitySet.Activities?.Count > 0)
{
System.Diagnostics.Debug.WriteLine($"{activitySet.Activities?.Count} activity/activities received");
}
#endif
_watermark = activitySet?.Watermark;
var activities = (from activity in activitySet.Activities
select activity)
.ToList();
if (_synchronizationContext != null)
{
_synchronizationContext.Post((o) => ActivitiesReceived?.Invoke(this, activities), null);
}
else
{
ActivitiesReceived?.Invoke(this, activities);
}
}
}
}
public ActionResult ActivityEdit()
{
try
{
ActivitySet activity = new ActivitySet();
int activityId = Convert.ToInt32(Request.Params["activityId"]);
activity = bll.getActivity(activityId);
return View(activity);
}
catch(Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
return RedirectToAction("ActivityPlanning");
}
//
//
public int createActivity(int projectId, DateTime startTime, DateTime endTime, string location, string description)
{
using(Youth_Center_DB_Conn db = new Youth_Center_DB_Conn())
{
try
{
var projects = from p in db.ProjectSets where p.Id == projectId select p;
if (projects.Any())
{
ActivitySet activity = new ActivitySet();
activity.startTime = startTime;
activity.endTime = endTime;
activity.location = location;
activity.description = description;
activity.ProjectSet = projects.First();
activity = db.ActivitySets.Add(activity);
db.SaveChanges();
return activity.Id;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
return -1;
}
}
