private void processRoomMessage(string roomId, MatrixRoomMessageEvent message) { string alias = message.Sender; string displayName = message.Sender; var channel = _channels.SingleOrDefault(c => (c.Id == roomId)); if (channel != null) { var sender = channel.Users.SingleOrDefault(u => (u.Id == message.Sender)); alias = sender.Alias; displayName = sender.DisplayName; } var messageModel = new ChatMessageModel() { Id = message.EventId, Provider = ChatServiceKind.Matrix, ProviderInstance = Name, AuthorId = message.Sender, AuthorAlias = alias, AuthorDisplayName = displayName, Body = message.Content?.Body, ChannelId = roomId, TimeSent = DateTimeOffset.FromUnixTimeMilliseconds( (long)message.OriginServerTimestamp), ThreadingId = "", Attachments = null, FromChatServiceConnection = this, IsFromTheorem = (message.Sender.Equals(_userId)), IsMentioningTheorem = false, }; onNewMessage(messageModel); }
public async Task <string> UpdateMessageAsync(string channelId, string messageId, ChatMessageModel message) { _logger.LogWarning("Mumble does not support editing messages - " + "sending a new message instead."); return(await SendMessageToChannelIdAsync(channelId, message)); }
public static void ShowMucInviteToast(MucDirectInvitationModel invite, ChatMessageModel msg, ChatModel chat) { ToastContent toastContent = new ToastContent { Visual = new ToastVisual { BindingGeneric = new ToastBindingGeneric { Children = { new AdaptiveText() { Text = string.IsNullOrEmpty(chat.contactInfo.name) ? chat.bareJid : chat.contactInfo.name, HintMaxLines = 1 }, new AdaptiveText() { Text = string.IsNullOrEmpty(invite.reason) ? "You have been invited to join " + invite.roomJid : invite.reason } }, AppLogoOverride = new ToastGenericAppLogo { Source = chat.chatType == ChatType.CHAT ? DEFAULT_USER_IMAGE_PATH : DEFAULT_MUC_IMAGE_PATH, HintCrop = ToastGenericAppLogoCrop.Circle } } }, DisplayTimestamp = msg.date, Launch = new ChatToastActivation(chat.id, msg.id).Generate() }; PopToast(toastContent, chat); }
private ChatMessageViewModel CreateMessageViewModel(ChatMessageModel model) { var viewModel = _viewModelFactoryService.ResolveViewModel <ChatMessageViewModel>(); viewModel.UpdateMessageModel(model); return(viewModel); }
public async Task <string> SendMessageToChannelIdAsync(string channelId, ChatMessageModel message) { var eventResponse = await sendTextMessageToRoomAsync(channelId, message.Body); return(eventResponse.EventId); }
public Block GetFormattedElement(ChatMessageModel chatMessage) { var userMessageParagraph = new Paragraph { KeepTogether = true, LineHeight = 1.0, Margin = new Thickness(0, 0, 0, 0) }; userMessageParagraph.Inlines.Add(messageLinksParser.Parse(chatMessage.chatMessageBody.message.FormatUsing(chatMessage.chatMessageBody.repository_url, chatMessage.chatMessageBody.url))); return userMessageParagraph; }
public String ChatMessages([FromForm] int id) { List <ChatMessage> msgs = _cdb.GetChatMessages(id); List <ChatMessageModel> rm = new List <ChatMessageModel>(); List <String> ids = msgs.Select(x => x.SenderId).Distinct().ToList(); List <IdentityUser> users = _db.Users.Where(x => ids.Contains(x.Id)).ToList(); msgs.ForEach(x => { ChatMessageModel cmm = new ChatMessageModel(); cmm.UserId = x.SenderId; cmm.MessageText = x.MessageText; cmm.MessageTime = x.SentTime; //ToDo: cmm.UserEmail = users.Where(y => y.Id == x.SenderId).Single().Email; rm.Add(cmm); }); //O(n) return(""); }
public MiddlewareResult ProcessMessage(ChatMessageModel message) { if (!(message.IsFromTheorem)) { // Is this from a service/channel that we relay messages from? var matchingRelays = _relays.Where(r => r.RelayChat && (r.FromChatService == message.FromChatServiceConnection) && (r.FromChannelId == message.ChannelId)); foreach (var relay in matchingRelays) { // replay this message to the destination if (relay.IsActive) { string displayName = message.AuthorId; if (message.AuthorAlias.Length > 0) { displayName = message.AuthorAlias; } if (message.AuthorDisplayName.Length > 0) { displayName = message.AuthorDisplayName; } relay.ToChatService.SendMessageToChannelIdAsync( relay.ToChannelId, new ChatMessageModel() { Body = $"{relay.ChatPrefix}{displayName}: {message.Body}", Attachments = message.Attachments?.ToList(), }); } } } return(MiddlewareResult.Continue); }
private async Task endAttendanceSessionAsync(RelayChannel relay) { // Edit the original message to mark when the call started, var startedMessageModel = new ChatMessageModel() { Body = relay.AttendanceStarted }; await relay.ToChatService .UpdateMessageAsync(relay.ToChannelId, relay.AttendanceSessionMessageId, startedMessageModel); // ... and post a new message to show when the call ended. var duration = DateTimeOffset.Now - relay.AttendanceSessionStarted; var durationStr = duration.ToString("h'h 'm'm 's's'"); var totalAttendanceStr = string.Join(", ", relay.TotalAttendanceSessionUsers.Select(u => u.DisplayName)); var messageBody = $"{relay.AttendanceEndedPrefix} Duration: {durationStr}, " + $"Participants: {totalAttendanceStr}"; var messageModel = new ChatMessageModel() { Body = messageBody }; await relay.ToChatService .SendMessageToChannelIdAsync(relay.ToChannelId, messageModel); relay.AttendanceSessionStarted = DateTimeOffset.MinValue; relay.AttendanceSessionMessageId = ""; relay.CurrentAttendanceSessionUsers.Clear(); relay.TotalAttendanceSessionUsers.Clear(); }
// name of receiver public async Task <string> SendMessageOneToOne(ChatMessageModel chatMessageModel) { // TimeZoneInfo timeInfo = TimeZoneInfo.FindSystemTimeZoneById("New Zealand Standard Time"); // var returnedMessageTime = TimeZoneInfo.ConvertTimeFromUtc(chatMessageModel.CreateAt ?? DateTime.Now, timeInfo); //var connectionId = Context.ConnectionId; var returnedMessageTime = chatMessageModel.CreateAt ?? DateTime.Now; try { var senderRoleId = _ablemusicContext.User.Where(x => x.UserId == chatMessageModel.SenderUserId) .Select(x => x.RoleId).FirstOrDefault(); if (senderRoleId == null) { return("Cannot find userId of message sender"); } var roleName = _ablemusicContext.Role.Where(x => x.RoleId == senderRoleId).Select(x => x.RoleName) .First(); await Clients.User(chatMessageModel.ReceiverUserId.ToString()) .SendAsync("SendMessageOneToOne", chatMessageModel.SenderUserId, chatMessageModel.MessageBody, returnedMessageTime.ToString("G"), roleName); } catch (Exception e) { return(e.Message); } return("Message send"); }
//--------------------------------------------------------Events:---------------------------------------------------------------------\\ #region --Events-- private void OnOmemoSessionBuildError(XMPPClient xmppClient, OmemoSessionBuildErrorEventArgs args) { Task.Run(() => { ChatModel chat; using (SemaLock semaLock = DataCache.INSTANCE.NewChatSemaLock()) { chat = DataCache.INSTANCE.GetChat(xmppClient.getXMPPAccount().getBareJid(), args.CHAT_JID, semaLock); } if (!(chat is null)) { // Add an error chat message: ChatMessageModel msg = new ChatMessageModel() { chatId = chat.id, date = DateTime.Now, fromBareJid = args.CHAT_JID, isCC = false, isDummyMessage = false, isEncrypted = false, isFavorite = false, isImage = false, message = "Failed to encrypt and send " + args.MESSAGES.Count + " OMEMO message(s) with:\n" + args.ERROR, stableId = AbstractMessage.getRandomId(), state = MessageState.UNREAD, type = MessageMessage.TYPE_ERROR }; DataCache.INSTANCE.AddChatMessage(msg, chat); // Set chat messages to encrypted failed: SetOmemoChatMessagesSendFailed(args.MESSAGES, chat); } }); }
public MiddlewareResult ProcessMessage(ChatMessageModel message) { // Ignore messages from ourself if (message.IsFromTheorem) { return(MiddlewareResult.Continue); } // Ignore messages that don't mention us, unless they're private messages if (!message.IsMentioningTheorem && !message.IsPrivateMessage) { return(MiddlewareResult.Continue); } var serviceConnection = message.FromChatServiceConnection; var printList = message.Body.Contains("ordered") ? _orderedMiddleware : (message.Body.Contains("disabled") ? _disabledMiddleware : _alphabeticallyOrderedMiddleware); serviceConnection .SendMessageToChannelIdAsync( message.ChannelId, new ChatMessageModel() { Body = "Available middleware: " + printList }) .Wait(); return(MiddlewareResult.Stop); }
private void AddLatestMessage(ChatMessageModel message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } var messageViewModel = CreateMessageViewModel(message); if (TryAddMessageToCache(message)) { _messageAdded.OnNext(messageViewModel); var chat = new ChatSummaryModel { Id = messageViewModel.ChatId }; if (TryAddChat(chat)) { UpdateChatsListFromNetworkAsync(); } FindChatForUpdateLastMessage(message); } }
public static void ShowChatTextToast(ChatMessageModel msg, ChatModel chat) { ToastContent toastContent = new ToastContent { Visual = new ToastVisual { BindingGeneric = new ToastBindingGeneric { Children = { new AdaptiveText() { Text = chat.bareJid, HintMaxLines = 1 }, new AdaptiveText() { Text = msg.message } }, AppLogoOverride = new ToastGenericAppLogo { Source = chat.chatType == ChatType.CHAT ? DEFAULT_USER_IMAGE_PATH : DEFAULT_MUC_IMAGE_PATH, HintCrop = ToastGenericAppLogoCrop.Circle } } }, Actions = GetActions(msg, chat), DisplayTimestamp = msg.date, Launch = new ChatToastActivation(chat.id, msg.id).Generate() }; PopToast(toastContent, chat); }
/// <summary> /// Написать сообщение /// </summary> /// <param name="model"></param> /// <returns></returns> public Task <BaseApiResponse <ChatMessageModel> > SendMessage(SendMessageToChat model) { var ticks = DateTime.UtcNow.Ticks; var id = Guid.NewGuid().ToString(); CreateHandled(new EccChatMessage { Id = id, ChatId = model.ChatId, TagString = model.TagString, SentOnUtcTicks = ticks, LastUpdateOnUtcTicks = ticks, Message = model.Message, SenderUserId = UserId }); var resModel = new ChatMessageModel { Id = id, Message = model.Message, LastUpdateUtcTicks = ticks, SenderUserId = UserId, SentOnUtcTicks = ticks, TagString = model.TagString }; return(TrySaveChangesAndReturnResultAsync("Сообщение отправлено", resModel)); }
public String UserMessage(String data) { data = data.Replace("'", "''"); String temp = Guid.NewGuid().ToString(); String temp1 = String.Join("", temp.Take(5)); String temp2 = String.Join("", temp.Skip(5).Take(5)); ChatData d = new ChatData(); d.Users.Add("*****@*****.**"); d.Users.Add("*****@*****.**"); ChatMessageModel cm = new ChatMessageModel(); cm.MessageText = data + temp1; cm.UserEmail = "1234"; ChatMessageModel cm2 = new ChatMessageModel(); cm2.MessageText = data + temp2; cm2.UserEmail = "5678"; d.Messages.AddRange(new [] { cm, cm2 }); return(JsonConvert.SerializeObject(d)); }
public ActionResult Send(ChatMessageModel model) { _ilog.Info(string.Format("方法名:{0};参数:{1}", "SendChatMessage", Serializer.ToJson(model))); var result = new StandardJsonResult <dynamic>(); result.Try(() => { if (!ModelState.IsValid) { throw new KnownException(ModelState.GetFirstError()); } var isSuccess = service.ProcessChatMessage(new ChatMessageDto() { SendUserID = BCSession.User.UserID, Recipients = model.Recipients, SendTime = model.SendTime, Message = model.Message, MessageID = model.MessageID }); result.Value = new { isSend = isSuccess }; }); _ilog.Info(string.Format("方法名:{0};执行结果:{1}", "SendChatMessage", Serializer.ToJson(result))); return(result); }
// sends a message to a room, conversation or user public async Task <IHttpActionResult> SendChatMessage(ChatMessageModel message) { message.FromID = CurrentUser.UserID; message.CreatedOn = DateTime.Now; ModelState.Remove("message.FromID"); ModelState.Remove("message.CreatedOn"); message.PostedByName = CurrentUser.FullName; message.PostedByAvatar = CurrentUser.ProfilePicture; if (ModelState.IsValid) { try { BroadcastChatMessage model = _chat.SendChatMessage(message); await _broadcaster.SendChatMessage(model, message.broadCastType); return(Ok(model.ChatMessage)); } catch (Exception ex) { Logs.Error("Error adding message to page", ex); return(BadRequest(ex.Message)); } } else { return(BadRequest(ModelState.JsonValidation())); } }
public async Task SendMessage(string message) { ChatUserModel user = null; if (_userCache.TryGetValue(CurrentUserId(), out user)) { if (user.ChatBanEnd.HasValue && user.ChatBanEnd.Value > DateTime.UtcNow) { return; } if (await IsSpam(user)) { return; } var chatMessage = new ChatMessageModel { Message = message, Timestamp = GetTime(), UserName = CurrentUserName(), Icon = user.ChatIcon, IsEnabled = true, }; await SaveMessage(chatMessage); await Clients.All.NewMessage(chatMessage, GetTime()); } }
public async Task SendMessage(ChatMessageViewModel chatMessage) { var chat = await _unitOfWork.Chats.GetByIdAsync(chatMessage.ChatId); var user = await _unitOfWork.Users.GetUserByNameAsync(chatMessage.UserName); var currentUser = await _unitOfWork.Users.GetUserByNameAsync(Context.User.Identity.Name); //await AddUserToChat(currentUser, chat.Name); //await AddUserToChat(user, chat.Name); var message = new ChatMessageModel { MessageText = chatMessage.Message, MessageDate = DateTime.Now, UserAvatarUrl = user.UserProfile?.AvatarUrl, UserName = chatMessage.UserName }; await Clients.Group(chat.Id.ToString()).SendAsync("SendMessage", message); //await Clients.Caller.SendAsync("SendMessage",message); chat.Messages.Add(new ChatMessage { Chat = chat, Message = chatMessage.Message, User = user, Date = DateTime.Now }); await _unitOfWork.SaveChangesAsync(); }
public MiddlewareResult ProcessMessage(ChatMessageModel message) { // Ignore messages from ourself if (message.IsFromTheorem) { return(MiddlewareResult.Continue); } // Ignore messages that don't mention us, unless they're private messages if (!message.IsMentioningTheorem && !message.IsPrivateMessage) { return(MiddlewareResult.Continue); } var serviceConnection = message.FromChatServiceConnection; var verbList = string.Join('\n', _middlewareVerbs.ToList() .Select(kvp => kvp.Key + " -> " + kvp.Value)); serviceConnection .SendMessageToChannelIdAsync( message.ChannelId, new ChatMessageModel() { Body = ("Available commands: \n\n" + verbList), }) .Wait(); return(MiddlewareResult.Stop); }
public async Task <IActionResult> PostOfflineMessage(ChatMessageModel chatMessageModel) { Result <ChatMessageModel> result = new Result <ChatMessageModel>(); ChatMessage chatMessage = new ChatMessage(); try { var receiver = await _ablemusicContext.User.Where(x => x.UserId == chatMessageModel.ReceiverUserId) .FirstOrDefaultAsync(); if (receiver == null) { result.ErrorMessage = "Can not find the message receiver."; return(NotFound(result)); } _mapper.Map(chatMessageModel, chatMessage); await _ablemusicContext.ChatMessage.AddAsync(chatMessage); await _ablemusicContext.SaveChangesAsync(); receiver.UnreadMessageId = chatMessage.ChatMessageId; await _ablemusicContext.SaveChangesAsync(); } catch (Exception e) { result.ErrorMessage = e.Message; result.IsSuccess = false; return(BadRequest(result)); } result.Data = chatMessageModel; return(Ok(result)); }
private static ToastActionsCustom GetActions(ChatMessageModel msg, ChatModel chat) { return(new ToastActionsCustom { Inputs = { new ToastTextBox(TEXT_BOX_ID) { PlaceholderContent = "Reply" } }, Buttons = { new ToastButton("Send", new SendReplyToastActivation(chat.id, msg.id).Generate()) { ActivationType = ToastActivationType.Background, ImageUri = chat.omemoInfo.enabled ? SEND_BUTTON_ENCRYPTED_IMAGE_PATH : SEND_BUTTON_IMAGE_PATH, TextBoxId = TEXT_BOX_ID, }, new ToastButton("Mark chat as read", new MarkChatAsReadToastActivation(chat.id, false).Generate()) { ActivationType = ToastActivationType.Background }, new ToastButton("Mark as read", new MarkMessageAsReadToastActivation(chat.id, msg.id).Generate()) { ActivationType = ToastActivationType.Background } } }); }
public async Task SendChat(string authCode, string message) { var authModel = Authenticate(authCode); //TODO chage the put endpoitn so it works with client chat ChatMessageModel chatMessageModel = new ChatMessageModel() { JobRef = authModel.JobRef.Value, Message = message, MessageTypeId = (int)ChatMessageType.Clientchat, User = new GarageUserModel() { FirstName = "a", LastName = "Other", Email = "*****@*****.**" } }; var client = await GetClient("api/v1/GarageChat/"); try { await client.WithJsonContent <ChatMessageModel>(chatMessageModel) .AddCustomHeader("X-BAYCONNECT-GARAGEREF", authModel.GarageRef.ToString()) .PutAsyncAndGetResponse <ChatPutResponseModel>(); } catch (Exception e) { Console.WriteLine(e); throw; } }
public IncomingMessageItemControl() { InitializeComponent(); BindingContext = new ChatMessageModel(); _ = ChangeVisibilityAsync(); }
public void SendChat(PlayerModel player, string chatMessage, string chatRoomKey) { ChatMessageModel chatMessageModel = new ChatMessageModel { Message = chatMessage, RoomKey = chatRoomKey }; playerAdapter.SendChat(player, chatMessageModel); }
public ChatMessage Map(ChatMessageModel message) => new ChatMessage { Id = message.Id, ChatroomId = message.ChatroomId, CreatedAt = message.CreatedAt, Text = message.Text, CreatedById = message.CreatedById };
public void SendChat(PlayerModel player, ChatMessageModel chatMessage) { Message msg = new Message(); msg.body.Add("player", player); msg.body.Add("message", chatMessage); mainServer.Emit("chatSent", msg.ToJson()); }
public void Create(ChatMessageModel model) { this.ChatMessage = model.ChatMessage; this.UserID = model.UserID; this.Username = model.Username; this.Color = model.Color; this.Time = model.Time; }
private void onNewMessage(ChatMessageModel message) { var eventHandler = MessageReceived; if (eventHandler != null) { eventHandler(this, message); } }
public async Task SendChatMessage(string user, string message) { var text = $"{user} : {message}"; var chatMessage = new ChatMessage(text); ChatManager.AddMessage(chatMessage); var model = new ChatMessageModel(chatMessage); await Clients.All.SendAsync("ReceiveMessage", model); }
public Paragraph GetFormattedElement(ChatMessageModel chatMessage, int lastUserThatInserted) { var user = ""; if (lastUserThatInserted != Convert.ToInt32(chatMessage.user_id)) { user = chatMessage.username; } var paragraph = new Paragraph {KeepTogether = true, LineHeight = 1.0, Margin = new Thickness(0, 0, 0, 0)}; paragraph.Inlines.Add(new Bold(new Run(user))); return paragraph; }
public void ResetControls() { if (editingMessage == null) return; if (inputMethod == null) return; inputMethod.Clear(); if (!editingMessageModel.chatMessageBody.IsCode){ currentRowGroup.Background = originalBackground; inputMethod.Background = originalBackground; inputMethod.PreviewKeyDown -= CancelEditMessage; inputMethod.TextChanged -= OnInputMethodTextChanged; inputMethod.LostFocus -= inputMethod_LostFocus; } currentRowGroup = null; editingMessage = null; editingMessageModel = null; comboRooms.IsEnabled = true; applicationGlobalState.IsEditingCode = false; }
public void EditMessage(object sender, MouseButtonEventArgs mouseButtonEventArgs) { if (mouseButtonEventArgs.ClickCount != 2) return; var row = (TableRowGroup)sender; if (currentRowGroup != null) ResetControls(); editingMessage = row.Resources["originalMessage"].Cast<Collection.Messages>(); if (editingMessage == null) return; var userId = Collection.getField(editingMessage.data, "user_id"); editingMessageModel = new ChatMessageModel { user_id = userId, username = Collection.getField(editingMessage.data, "user"), body = Collection.getField(editingMessage.data, "body") }; var chatMessageBody = editingMessageModel.chatMessageBody; if (chatMessageBody.IsCode) { chatMessageBody.stamp = ""; editingMessageModel.chatMessageBody = chatMessageBody; inputMethod.Clear(); var editedCode = codeEditor.Show(editingMessageModel.chatMessageBody.message, editingMessageModel.chatMessageBody.programminglanguage); if(editedCode.Trim()!= ""){ editingMessageModel.chatMessageBody.message = editedCode; inputMethod.AppendCode(editingMessageModel); //inputMethod.Text = editingMessageModel.chatMessageBody.message; } }else{ SetControls(row); applicationGlobalState.IsEditingCode = true; } }
public Paragraph GetFormattedElement(ChatMessageModel chatMessage) { var dateTime = FormatDate(DateTime.Parse(chatMessage.date)); return new Paragraph(new Bold(new Run(dateTime))) { KeepTogether = true, LineHeight = 1.0, Margin = new Thickness(0, 0, 0, 0) }; }