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; } }