public static ChatMessagesDto ConvertToDto(ChatMessages chatMessages)
{
ChatMessagesDto newChatMessages = new ChatMessagesDto();
newChatMessages.Date = chatMessages.Date;
newChatMessages.Id = chatMessages.Id;
newChatMessages.GroupId = chatMessages.GroupId;
newChatMessages.Body = chatMessages.Body;
newChatMessages.UserId = chatMessages.UserId;
return(newChatMessages);
}
private async Task LoadChatMessages(DateTime datetime, bool isNewChatQuery)
{
if (isNewChatQuery)
{
EndTime = DateTime.Now;
}
else
{
IsScrollingTop = true;
}
List <ChatMessage> listChat = await _networkService.QueryChatAsync(App.User.api_token, EventId, Constants.ChatType.ExternalChat, isNewChatQuery, datetime);
var hasNewChat = false;
if (listChat != null && listChat.Count > 0)
{
if (isNewChatQuery)
{
listChat.Reverse();
}
foreach (var chat in listChat)
{
chat.IsFromMe = chat.UserID == App.User.ID;
if (chat.CreateTime != DateTime.MinValue && BeginTime > chat.CreateTime)
{
BeginTime = chat.CreateTime.Value;
}
if (isNewChatQuery)
{
var existed = ChatMessages.Any(c => c.ChatID == chat.ChatID);
if (!existed)
{
hasNewChat = true;
ChatMessages.Add(chat);
}
}
else
{
hasNewChat = true;
ChatMessages.Insert(0, chat);
}
}
}
if (hasNewChat)
{
await RaisePropertyChanged(nameof(ChatMessages));
}
if (hasNewChat && isNewChatQuery && !IsScrollingTop)
{
await RaisePropertyChanged(nameof(RequestScroll));
}
}
public void Add(MessageViewModel model)
{
StartMessaging(model.UserId, model.RecieverUserId);
var chatId = _db.Chat
.FirstOrDefault(e => (e.UserId == model.UserId && e.OtherUserId == model.RecieverUserId));
var temp = new ChatMessages {
ChatId = chatId.ChatId, ChatMessageText = model.MessageText, ChatMessagesSendDate = DateTime.Now
};
_db.ChatMessages.Add(temp);
_db.SaveChanges();
}
public ActionResult AddMessage(int id)
{
Accounts senderAccounts = (Accounts)Session["loggedin_Accounts"];
ChatMessages mess = new ChatMessages();
mess.SenderEmail = senderAccounts.Email;
Contacts recieverAccounts = ContactsRepository.GetContacts(id);
mess.RecieverEmail = recieverAccounts.Email;
ViewBag.Title = recieverAccounts.Name;
return(View(mess));
}
public void SubmitChatMessage()
{
if (string.IsNullOrEmpty(ChatMessage))
{
return;
}
ChatMessages.Add(new ChatMessage {
Message = ChatMessage
});
ChatMessage = string.Empty;
}
public IActionResult AddChat([FromBody] ChatMessagesRequest chatRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var chats = new ChatMessages(chatRequest);
_context.ChatMessages.Add(chats);
_context.Commit();
return(Ok(new { msg = "Chat added" }));
}
public bool TryParseMessage(WowChat type, long timestamp, List <string> args)
{
if (args.Count < 6)
{
return(false);
}
WowChatMessage chatMessage = new(type, timestamp, args);
ChatMessages.Add(chatMessage);
if (Config.ChatProtocols)
{
try
{
string typeName = chatMessage.Type switch
{
WowChat.ADDON => "misc",
WowChat.CHANNEL => "channel",
WowChat.DND => "misc",
WowChat.FILTERED => "filtered",
WowChat.GUILD => "guild",
WowChat.GUILD_ACHIEVEMENT => "guild",
WowChat.IGNORED => "misc",
WowChat.MONSTER_EMOTE => "npc",
WowChat.MONSTER_PARTY => "npc",
WowChat.MONSTER_SAY => "npc",
WowChat.MONSTER_WHISPER => "npc",
WowChat.MONSTER_YELL => "npc",
WowChat.RAID_BOSS_EMOTE => "npc",
WowChat.RAID_BOSS_WHISPER => "npc",
WowChat.SYSTEM => "system",
_ => "normal",
};
string protocolName = ProtocolName(typeName);
string dirName = Path.GetDirectoryName(protocolName);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
File.AppendAllText(protocolName, $"{chatMessage}\n");
}
catch { }
}
OnNewChatMessage?.Invoke(chatMessage);
return(true);
}
public ActionResult SendMessage(int id)
{
ChatMessages message = new ChatMessages();
Contacts receiverAccounts = ContactRepo.GetContacts(id); // gather contact details of desired user and store this into "receiverAccount"
Accounts senderAccounts = (Accounts)Session["LoggedInAccounts"]; // gather contact details of logged in user, who is sending the message
message.SenderEmail = senderAccounts.Email;
message.ReceiverEmail = receiverAccounts.Email;
message.Time = DateTime.Now;
ViewBag.Title = receiverAccounts.Name;
return(View(message));
}
private void TimerRefreshChat_Tick(object sender, EventArgs e)
{
int messageId = ChatServices.ReturnUnreadMessageId();
if (messageId > 0)
{
ChatMessages message = ChatServices.ReturnMessage(messageId);
RtbChat.AppendText(DateTime.Now.ToString() + " ");
RtbChat.AppendText($"from {ChatServices.GetUsers(message.sender_id)}" + "\r\n");
RtbChat.AppendText($"{message.Message}" + "\r\n");
ChatServices.SetFlagRead(messageId);
}
}
public static ChatMessagesDto AddChatMessage(AddChatMessageRequest request)
{
using (familydbEntities1 db = new familydbEntities1())
{
ChatMessages msg = db.ChatMessages.Add(Convertion.ChatMessagesConvertor.ConvertAddChatMessageRequestToChatMessages(request));
db.SaveChanges();
if (msg == null)
{
return(null);
}
return(Convertion.ChatMessagesConvertor.ConvertToDto(msg));
}
}
public void world_chat_message(string txt, string html)
{
//log.Debug(txt);
try
{
ChatType ct = ChatType.Other;
if (txt.Contains("[World]"))
{
ct = ChatType.World;
}
else if (txt.Contains("[Alliance]"))
{
ct = ChatType.Alliance;
}
else if (txt.Contains("[Officer]"))
{
ct = ChatType.Officers;
}
else if (txt.Contains("whisper"))
{
ct = ChatType.Whisper;
}
var cm = new JS.ChatMessage {
ChatType = ct, Message = txt
};
AnalyzeMsg(html, cm);
//muszę tak bo jestem w innym wątku... i może boleć
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
try
{
ChatMessages.Add(cm);
}
catch (Exception e)
{
log.Error(e.Message, e);
}
}), DispatcherPriority.Normal);
DoChatMessage(cm);
}
catch (Exception e)
{
log.Error(e.Message, e);
log.Error("Message: " + html);
}
}
public IActionResult SaveMessageToDatabase(int senderId, string senderMessage, int receiverId)
{
ChatMessages message = new ChatMessages();
message.SenderId = senderId;
message.ReceiverId = receiverId;
message.ChatMessage = senderMessage;
message.ChatTime = DateTime.Now;
_context.ChatMessages.Add(message);
_context.SaveChanges();
return(Ok());
}
public void Send(string date, string nickname, string message)
{
_mongoContext = new MongoContext();
var finalMessage = EZChat_App.Helpers.BannedWordsFilterHelper.ReplaceBadWords(message);
var chatMessages = new ChatMessages()
{
username = nickname,
dateTime = date,
message = finalMessage
};
_mongoContext.database.GetCollection <ChatMessages>("ChatMessages").Insert <ChatMessages>(chatMessages);
Clients.All.addNewMessageToPage(date, nickname, finalMessage);
}
public IHttpActionResult DeleteChatMessages(int id)
{
ChatMessages chatMessages = db.ChatMessages.Find(id);
if (chatMessages == null)
{
return(NotFound());
}
db.ChatMessages.Remove(chatMessages);
db.SaveChanges();
return(Ok(chatMessages));
}
private void AddTextRecieved(ChatLogEventArgs args)
{
var message = new ChatMessage
{
PrevSide = _curside,
SenderName = args.Sender,
Text = args.Message,
Side = MessageSide.You
};
if (ChatSettings.IsTimestampingEnabled)
{
message.Timestamp = args.Timestamp;
}
ChatMessages.Add(message);
_curside = MessageSide.You;
if (ChatSettings.IsAutoScrollEnabled)
{
View.ScrollConversationToEnd();
}
try
{
if (!ChatSettings.IsNotificationsEnabled || ChatSettings.NotificationString == null)
{
return;
}
if (ChatSettings.NotificationWords.Any(s => message.Text.Contains(s)))
{
ShowCustomBalloon($"{message.SenderName}: {message.Text}");
}
if (ChatSettings.IsFlashWindowNotificationEnabled)
{
Application.Current.MainWindow.FlashWindow();
}
if (!ChatSettings.IsNotificationSoundFileEnabled || ChatSettings.NotificationSoundFile == null)
{
return;
}
SoundManager.PlayFile(ChatSettings.NotificationSoundFile);
}
catch (Exception ex)
{
App.LogErrorMessage(ex);
}
}
public void AddChatMessage(ChatMessage chatMessage)
{
if (!App.Settings.ChatEnabled)
{
return;
}
Dispatcher.InvokeAsync(() =>
{
if (Filtered(chatMessage))
{
return;
}
if (chatMessage is LfgMessage lm && !App.Settings.DisableLfgChatMessages)
{
lm.LinkListing();
}
chatMessage.SplitSimplePieces();
if (ChatWindows.All(x => !x.IsPaused))
{
#if BATCH
_mainQueue.Enqueue(chatMessage);
#else
ChatMessages.Insert(0, chatMessage);
#endif
}
else
{
_pauseQueue.Enqueue(chatMessage);
N(nameof(QueuedMessagesCount));
}
NewMessage?.Invoke(chatMessage);
#if BATCH
#else
if (ChatMessages.Count > App.Settings.MaxMessages)
{
var toRemove = ChatMessages[ChatMessages.Count - 1];
toRemove.Dispose();
ChatMessages.RemoveAt(ChatMessages.Count - 1);
}
N(nameof(MessageCount));
#endif
}, DispatcherPriority.DataBind);
}
/// <summary>
/// TODO: Only for debugging.
/// </summary>
public ChatViewModel()
{
ChatMessages.Add(new MessageModel()
{
Content = "Hello",
Who = C.ME,
Type = C.MSG_TYPE_TEXT
});
ChatMessages.Add(new MessageModel()
{
Content = "Thank you!",
Who = C.GIY,
Type = C.MSG_TYPE_TEXT
});
}
public static string GetChatMessages(RestCommand command)
{
ChatMessages chatMessages = new ChatMessages(command.LoginUser);
chatMessages.LoadByOrganizationID(command.Organization.OrganizationID);
if (command.Format == RestFormat.XML)
{
return(chatMessages.GetXml("ChatMessages", "ChatMessage", true, command.Filters));
}
else
{
throw new RestException(HttpStatusCode.BadRequest, "Invalid data format");
}
}
private void SaveSmartReplyMessage(string message)
{
ChatMessages smartMessage = new ChatMessages()
{
AnsweringUserId = Enums.SmartReplyAgentId,
ChatId = chatId,
Message = message,
MessageDate = DateTime.Now,
MessageDirection = Enums.ChatMessageFromUserAgent,
IsItRead = false,
};
unitOfWork.ChatMessages.Insert(smartMessage);
unitOfWork.SaveChanges();
}
public static string[] GetChatHtml(UserInfoProxy userInfo, int chatID, int lastMessageID)
{
LoginUser loginUser = new LoginUser(userInfo.UserID, userInfo.OrganizationID, null);
ChatUserSetting setting = ChatUserSettings.GetSetting(loginUser, loginUser.UserID);
setting.CurrentChatID = chatID;
setting.Collection.Save();
Chat chat = Chats.GetChat(loginUser, chatID);
if (chat == null || chat.OrganizationID != loginUser.OrganizationID)
{
return(null);
}
ChatMessages messages = new ChatMessages(loginUser);
int i = messages.GetLastMessageID(chatID);
string chatHtml = "";
if (i > -1 && i != lastMessageID)
{
ChatParticipants.UpdateLastMessageID(loginUser, loginUser.UserID, ChatParticipantType.User, chatID, i);
chatHtml = chat.GetHtml(true, loginUser.CultureInfo);
}
// load typers
ChatParticipants participants = new ChatParticipants(loginUser);
participants.LoadTypers(loginUser.UserID, ChatParticipantType.User, chatID, 2);
StringBuilder typers = new StringBuilder();
foreach (ChatParticipant item in participants)
{
if (typers.Length > 0)
{
typers.Append(", ");
}
typers.Append(item.FirstName);
}
if (typers.Length > 0)
{
typers.Append(" is typing a message.");
}
return(new string[] { chatID.ToString(), i.ToString(), chatHtml, typers.ToString() });
}
public bool SendMessageWithFileToUser(string fromUser, string toUser, string message, string ConnectionId, List <int> idMessageFile)
{
try
{
using (IDbContextTransaction transaction = context.Database.BeginTransaction())
{
try
{
var _message = new ChatMessages
{
CustomerUserId = toUser,
IsRead = false,
Message = message,
SenderUserId = fromUser,
ConnectionId = ConnectionId,
Date = DateTime.Now,
};
context.ChatMessages.Add(_message);
context.SaveChanges();
foreach (var item in idMessageFile)
{
ChatMessageFiles file = context.ChatMessageFiles.FirstOrDefault(x => x.IdChatMessageFile == item);
file.ChatMessageId = _message.IdChatMessage;
context.ChatMessageFiles.Update(file);
context.SaveChanges();
}
transaction.Commit();
return(true);
}
catch (Exception ex)
{
Log.Logger.Error(ex);
transaction.Rollback();
return(false);
}
}
}
catch (Exception ex)
{
Log.Logger.Error(ex);
return(false);
}
}
public ActionResult SendMessage(ChatMessages bericht)
{
if (bericht.Message == null) // check if the message is not empty, if so warn user that he or she forget to write the message
{
ModelState.AddModelError("Message-error", "oops, it seems you forget to type your message");
return(View(bericht));
}
else
{
if (ModelState.IsValid)
{
ChatRepo.AddChatMessages(bericht); // call the method that executes the operatian in the DB.
}
}
return(RedirectToAction("Index", "Chat"));
}
public async Task <ActionResult <ChatRoom> > PostChatRoom(ChatMessages message, int id)
{
var SM = _context.ChatRoomMember;
foreach (ChatRoomMembers c in SM)
{
if (c.chatRoomID == id && c.chatUserID == CurrentUser.usernameSession.chatUserID)
{
_context.ChatMessage.Add(message);
}
}
await _context.SaveChangesAsync();
return(NoContent());
}
private void GetDataFromFirebase()
{
Action <Dictionary <string, ChatMessage> > onValueEvent = (Dictionary <string, ChatMessage> messages) =>
{
try
{
System.Diagnostics.Debug.WriteLine("---> EVENT GetDataFromFirebase ");
Action onSetValueSuccess = () =>
{
};
Action <string> onSetValueError = (string errorDesc) =>
{
};
if (messages == null)
{
}
else
{
if (messages.Count != 0 && ChatMessages.Count != messages.Count)
{
foreach (var message in messages.OrderBy(m => m.Value.DateMessageTimeSpan))
{
message.Value.IsYourMessage = UserCurent.Name == message.Value.UserName;
if (ChatMessages.All(m => m.Id != message.Value.Id))
{
ChatMessages.Add(message.Value);
System.Diagnostics.Debug.WriteLine("---> add new -> " + message.Value.Id);
}
}
MessagingCenter.Send <ChatVM>(this, "ScrollToEnd");
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("---> error GetDataFromFirebase " + ex.Message);
throw;
}
};
_firebaseDatabase.AddValueEvent("chats", onValueEvent);
}
public async Task SendChatMessage()
{
if (string.IsNullOrWhiteSpace(InputText))
{
return;
}
var chatMessage = new ChatMessage(string.Empty, InputText);
InputText = string.Empty;
await PipeStreamWriter.WriteLineAsync(JsonSerializer.Serialize(chatMessage));
await PipeStreamWriter.FlushAsync();
chatMessage.SenderName = "You";
ChatMessages.Add(chatMessage);
}
public void HandleNewChatMessageEvent(NewChatMessageEventPayload eventPayload)
{
if (eventPayload == null)
{
throw new ArgumentNullException("eventPayload");
}
if (eventPayload.NewChatMessage.RequestForQuoteId == SelectedRequestForQuote.Identifier)
{
if (log.IsDebugEnabled)
{
log.Debug("Received new chat message: " + eventPayload);
}
ChatMessages.Add(eventPayload.NewChatMessage);
}
}
public async Task <IActionResult> Chat()
{
var currentUser = await this.userManager.GetUserAsync(this.User);
if (this.User.Identity.IsAuthenticated)
{
ViewBag.CurrentUserName = currentUser.UserName;
}
var viewModel = new ChatMessages();
viewModel.Messages = this.messagesService.GetAll <ChatViewModel>();
if (viewModel.Messages.Count() == 15)
{
await this.messagesService.DeleteFifteenthCommnet();
}
return(this.View(viewModel));
}
/// <summary>
/// Splits loaded messages in smaller parts to fit maximum text limit
/// and adds them to the chat records and chat window.
/// </summary>
/// <param name="friendName">username of user that chat messages belong to</param>
/// <param name="msgs">list of loaded chat messages</param>
/// <param name="initialLoad">true if the sroll bar in chat window should be moved to the bottom</param>
private void OnLoadMessagesSuccess(string friendName, ChatMessages msgs, bool initialLoad = false)
{
chatRecords[friendName].Loading = false;
RefreshLoadingIndicator();
if (msgs.Messages.Count == 0)
{
chatRecords[friendName].LoadedEveryMessage = true;
return;
}
var loadedMessages = new StringBuilder();
bool first = true;
var loadedMessagesHeight = 0f;
foreach (var msg in msgs.Messages.Reverse())
{
if (!first)
{
loadedMessages.AppendLine();
}
else
{
chatRecords[friendName].LastMessageId = msg.Id;
}
first = false;
var newMessage = FormatChatMessage(msg, true);
if (loadedMessages.Length + newMessage.Length > GAME_OBJECT_TEXT_LIMIT)
{
loadedMessagesHeight += PrependOldMessages(friendName, loadedMessages.ToString());
loadedMessages = new StringBuilder();
}
loadedMessages.Append(newMessage);
}
loadedMessagesHeight += PrependOldMessages(friendName, loadedMessages.ToString());
if (initialLoad)
{
Canvas.ForceUpdateCanvases();
ScrollRect.verticalNormalizedPosition = 0;
}
else
{
ScrollContent.anchoredPosition = new Vector2(0, loadedMessagesHeight);
}
}
private async Task SendText()
{
try
{
IsScrollingTop = false;
if (string.IsNullOrWhiteSpace(Message))
{
return;
}
var token = App.User.api_token;
var msg = new ChatMessage()
{
Content = Message,
IsFromMe = true,
CreateTime = DateTime.Now,
SurID = EventId,
Type = Constants.ChatType.InternalChat,
SendStatus = 0
};
ChatMessages.Add(msg);
Message = string.Empty;
await RaisePropertyChanged(nameof(Message));
await RaisePropertyChanged(nameof(ChatMessages));
await RaisePropertyChanged(nameof(RequestScroll));
var chat = await _networkService.SendChatAsync(token, msg.SurID, msg.Type, msg.Content, 0, App.User.ID);
if (chat != null)
{
msg.ChatID = chat.lastID;
}
else
{
msg.SendStatus = 2;
}
await RaisePropertyChanged(nameof(ChatMessages));
//Log.Info(Constants.AppConfig.LogTag, "Sent: " + msg.Content);
}
catch (Exception ex)
{
//Log.Error(Constants.AppConfig.LogTag, ex.ToString());
//Log.Error(Constants.AppConfig.LogTag, ex.StackTrace);
}
}
// POST
public void Post(ChatMessagesData msgData)
{
// System.Diagnostics.Debug.WriteLine("ChatId1111111111111111111111 " + msgData.Message);
var chat = db.Chat.Find(msgData.ChatId);
ChatMessages poraka = new ChatMessages()
{
Message = msgData.Message,
Date = DateTime.Now,
PostedBy = whoPostedFirst(chat.User1)
};
if (chat != null)
{
chat.Messages.Add(poraka);
db.SaveChanges();
}
}
