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