public SystemMessageNode(ChatMessageViewModel viewModel)
{
BackgroundColor = UIColor.FromRGB(245, 245, 245);
SelectionStyle = UITableViewCellSelectionStyle.None;
AutomaticallyManagesSubnodes = true;
var attributedText = viewModel.Body
.BuildAttributedString()
.Font(UIFont.SystemFontOfSize(11, UIFontWeight.Semibold))
.Foreground(UIColor.FromRGB(255, 255, 255));
_messageNode.AttributedText = attributedText;
}
public InfoMessageNode(ChatMessageViewModel viewModel)
{
_infoTextNode = new ASTextNode();
var attributedInfoText = viewModel?.Body.BuildAttributedString()
.Font(UIFont.SystemFontOfSize(11, UIFontWeight.Semibold))
.Foreground(UIColor.FromRGB(141, 141, 141));
_infoTextNode.AttributedText = attributedInfoText;
SelectionStyle = UITableViewCellSelectionStyle.None;
AutomaticallyManagesSubnodes = true;
SetNeedsLayout();
}
private void MessageWhisperUserMenuItem_Click(object sender, RoutedEventArgs e)
{
if (this.ChatList.SelectedItem != null && this.ChatList.SelectedItem is ChatMessageViewModel)
{
ChatMessageViewModel message = (ChatMessageViewModel)this.ChatList.SelectedItem;
if (message.User != null)
{
this.viewModel.SendMessageText = $"/w @{message.User.Username} ";
this.ChatMessageTextBox.Focus();
this.ChatMessageTextBox.CaretIndex = this.ChatMessageTextBox.Text.Length;
}
}
}
// GET: ChatMessages
public ActionResult Index()
{
messageListVM = new List <ChatMessageViewModel>();
messageList = new List <ChatMessage>();
messageList = db.ChatMessages.ToList();
appUserList = db.AppUserModels.ToList();
groupList = db.GroupModels.ToList();
ChatMessageViewModel chatMessage = new ChatMessageViewModel();
foreach (ChatMessage u in messageList)
{
chatItem = new ChatMessageViewModel();
user = appUserList.Find(x => x.ID == u.UserId);
group = groupList.Find(x => x.ID == u.GroupId);
chatItem.Id = u.ChatId;
chatItem.Date = u.TimeStamp.ToShortDateString();
chatItem.Time = u.TimeStamp.ToLongTimeString();
chatItem.Name = u.Name;
chatItem.Message = u.Message;
chatItem.isFlagged = u.isFlagged;
if (user != null)
{
chatItem.UserName = user.Name;
}
else
{
chatItem.UserName = u.Name;
}
if (group != null)
{
chatItem.GroupName = group.GroupName;
}
else
{
chatItem.GroupName = "**deleted**";
}
messageListVM.Add(chatItem);
}
return(View(messageListVM.ToList()));
}
public static bool DoesMessageMatchWildcardTriggers(ChatMessageViewModel message, IEnumerable <string> triggers, out IEnumerable <string> arguments)
{
arguments = null;
foreach (string trigger in triggers)
{
Match match = Regex.Match(message.PlainTextMessage, string.Format(CommandWildcardMatchingRegexFormat, Regex.Escape(trigger)), RegexOptions.IgnoreCase);
if (match != null && match.Success)
{
arguments = message.PlainTextMessage.Substring(match.Index + match.Length).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return(true);
}
}
return(false);
}
private void TryUpdateTempMessageAfterSend(ChatMessageViewModel tempMessageViewModel,
ChatMessageModel sentMessage)
{
try
{
_messagesCache.UpdateSentMessage(tempMessageViewModel.Model, sentMessage);
tempMessageViewModel.UpdateMessageModel(sentMessage);
}
catch (ChatCacheException e)
{
_logger.Error(e);
}
}
private async Task <bool> CheckMessageForCommandAndRun(ChatMessageViewModel message)
{
PermissionsCommandBase command = this.CheckMessageForCommand(message);
if (command != null)
{
Util.Logger.LogDiagnostic(string.Format("Command Found For Message - {0} - {1}", message.ToString(), command.ToString()));
await this.RunMessageCommand(message, command);
return(true);
}
return(false);
}
internal void ProcessMessage(ChatMessageViewModel viewModel, bool suppressUnreadNotifications = false)
{
viewModel.HasBeenSeen = IsRoomVisible(suppressUnreadNotifications);
var lastGroupMessage = _messages.LastOrDefault() as ChatMessageGroupViewModel;
if (lastGroupMessage == null || !lastGroupMessage.TryAddMessage(viewModel))
{
var groupViewModel = new ChatMessageGroupViewModel(viewModel);
_messages.Add(groupViewModel);
}
UpdateUnreadMessageCount();
}
private async void BotChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = new ChatMessageViewModel(e);
if (message.IsWhisper)
{
message = await this.AddMessage(e);
if (message != null)
{
this.OnMessageOccurred(sender, message);
}
}
}
public Task ProcessMessageAsync(string room, Message message)
{
var task = new Task <ChatMessageViewModel>(() =>
{
ChatMessageViewModel msgVm = CreateMessageViewModel(message);
return(msgVm);
});
task.ContinueWith(completedTask => OnMessageProcessed(completedTask.Result, room),
TaskContinuationOptions.OnlyOnRanToCompletion);
task.ContinueWith(ProcessTaskExceptions, TaskContinuationOptions.OnlyOnFaulted);
task.Start();
return(task);
}
private async Task RunChatCommand(ChatMessageViewModel message, CommandModelBase command, IEnumerable <string> arguments)
{
Logger.Log(LogLevel.Debug, string.Format("Command Found For Message - {0} - {1} - {2}", message.ID, message, command));
await command.Perform(new CommandParametersModel(message.User, message.Platform, arguments));
SettingsRequirementModel settings = command.Requirements.Settings;
if (settings != null)
{
if (settings != null && settings.ShouldChatMessageBeDeletedWhenRun)
{
await this.DeleteMessage(message);
}
}
}
public MessageViewModel GetMessageModel(ChatMessageViewModel objentity)
{
MessageViewModel objmodel = new MessageViewModel();
objmodel.ChatMessageId = objentity.ChatMessageId;
objmodel.FromUserId = objentity.FromUserId;
objmodel.ToUserId = objentity.ToUserId;
objmodel.Message = objentity.Message;
objmodel.Status = objentity.Status;
objmodel.CreatedOn = Convert.ToString(objentity.CreatedOn);
objmodel.UpdatedOn = Convert.ToString(objentity.UpdatedOn);
objmodel.ViewedOn = Convert.ToString(objentity.ViewedOn);
objmodel.IsActive = objentity.IsActive;
return(objmodel);
}
public static bool DoesMessageMatchTriggers(ChatMessageViewModel message, IEnumerable <string> triggers, out IEnumerable <string> arguments)
{
arguments = null;
if (!string.IsNullOrEmpty(message.PlainTextMessage))
{
foreach (string trigger in triggers)
{
if (string.Equals(message.PlainTextMessage, trigger, StringComparison.CurrentCultureIgnoreCase) || message.PlainTextMessage.StartsWith(trigger + " "))
{
arguments = message.PlainTextMessage.Replace(trigger, "").Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return(true);
}
}
}
return(false);
}
public async Task SendMessage(ChatMessageViewModel message)
{
var user = await _userManager.FindByNameAsync(message.Username);
var messageToSave = new ChatMessage()
{
MessageBody = message.MessageBody,
User = user,
CreatedDate = message.CreatedDate,
};
// Store message in repository
_messagerepo.SaveMessage(messageToSave);
await Clients.All.SendAsync("ReceiveMessage", message);
}
public async Task SendMessage(string message,
string userId)
{
var messageOwner = await _userService.GetUserByIdAsync(userId);
var chatMessage = await _chatService.SaveMessageAsync(message,
messageOwner);
var chatMessageViewModel = new ChatMessageViewModel(chatMessage);
await Clients.All.SendAsync("ReceiveMessage",
JsonConvert.SerializeObject(chatMessageViewModel,
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
}
public IActionResult CreateMessages([FromBody] ChatMessageViewModel viewModel)
{
try
{
_chatMessageService.CreateMessage(viewModel);
return(Ok());
}
catch (CustomException ex)
{
return(StatusCode(ex.StatusCode, ex.Message));
}
catch (Exception ex)
{
WriteExceptionInfo(ex);
return(StatusCode(500));
}
}
public void FormatChatMessageTest()
{
var vm = new SampleChatMessageCollectionViewModel();
var formatter = new TestChatFormattingService(vm.ViewModels, vm.UserVm);
int initialCount = formatter.FormattedMessages.Blocks.Count;
Assert.AreEqual(vm.ViewModels.Count, initialCount);
bool getParagraphsFromChatMessageCalled = false;
formatter.GetParagraphsFromChatMessageCalled += (s, e) => getParagraphsFromChatMessageCalled = true;
var chatVm = new ChatMessageViewModel {
Model = DesignTimeHelper.GetChatMessage(user)
};
formatter.AddMessage(chatVm);
Assert.IsTrue(getParagraphsFromChatMessageCalled);
Assert.AreEqual(initialCount + 1, formatter.FormattedMessages.Blocks.Count);
}
public ActionResult _Messages(string Id)
{
var userModel = _defaultHelper.GetUserModel(Id);
var messages = new MessageRecordViewModel();//_MessageServiceAgent.GetChatMessagesByUserId(User.Identity.GetUserId(), Id);
var objmodel = new ChatMessageViewModel();
objmodel.UserDetail = userModel;
objmodel.ChatMessages = messages.Messages.Select(m => _defaultHelper.GetMessageModel(m)).ToList();
objmodel.LastChatMessageId = messages.LastChatMessageId;
var onlineStatus = _userServiceAgent.GetUserOnlineStatus(Id);
if (onlineStatus != null)
{
objmodel.IsOnline = onlineStatus.IsOnline;
objmodel.LastSeen = Convert.ToString(onlineStatus.LastUpdationTime);
}
return(PartialView(objmodel));
}
private ContextMenuComponent CreateContextMenuComponentForViewModel(ChatMessageViewModel message)
{
var contextMenuComponent = new ContextMenuComponent();
var commandActions = ViewModel.GetCommandActionsForMessage(message);
switch (commandActions.Count)
{
case 1:
contextMenuComponent.AddCommand(ContextMenuActions.Delete, commandActions[0]);
break;
case 2:
contextMenuComponent.AddCommand(ContextMenuActions.Edit, commandActions[0]);
contextMenuComponent.AddCommand(ContextMenuActions.Delete, commandActions[1]);
break;
}
return(contextMenuComponent);
}
public void SendMessage(string fromUserId, string toUserId, string message, string fromUserName, string fromUserProfilePic, string toUserName, string toUserProfilePic)
{
ChatMessageViewModel objentity = new ChatMessageViewModel();
objentity.CreatedOn = System.DateTime.Now;
objentity.FromUserId = fromUserId;
objentity.IsActive = true;
objentity.Message = message;
objentity.ViewedOn = System.DateTime.Now;
objentity.Status = "Sent";
objentity.ToUserId = toUserId;
objentity.UpdatedOn = System.DateTime.Now;
var obj = _messageServiceAgent.SaveChatMessage(objentity);
var messageRow = _defaultHelper.GetMessageModel(obj);
List <string> connectionIds = _userServiceAgent.GetUsersConnectionId(new string[] { fromUserId, toUserId });
Clients.Clients(connectionIds).AddNewChatMessage(messageRow, fromUserId, toUserId, fromUserName, fromUserProfilePic, toUserName, toUserProfilePic);
}
public void Send(ChatMessageViewModel message)
{
if (!string.IsNullOrEmpty(message.Content))
{
// Sanitize input
message.Content = HttpUtility.HtmlEncode(message.Content);
// Process URLs: Extract any URL and process rich content (e.g. Youtube links)
HashSet <string> extractedURLs;
message.Content = TextParser.TransformAndExtractUrls(message.Content, out extractedURLs);
message.Timestamp = DateTime.Now;
// Save the message to the database
_repository.AddMessageToDatabase(message);
// Notice members on a message received
Clients.Group(message.EventId.ToString()).onMessageReceived(message);
}
}
protected override async Task <string> PerformReplacement(string text, UserViewModel user, IEnumerable <string> arguments, Dictionary <string, string> extraSpecialIdentifiers)
{
ChatMessageViewModel message = this.messagesToProcess.First();
if (message.Skill != null || message.ChatSkill != null)
{
text = text.Replace("{MESSAGE}", OverlayChatMessages.SkillImageMessageHTMLTemplate);
}
else
{
text = text.Replace("{MESSAGE}", OverlayChatMessages.TextMessageHTMLTemplate);
}
foreach (var kvp in await this.GetReplacementSets(user, arguments, extraSpecialIdentifiers))
{
text = text.Replace($"{{{kvp.Key}}}", kvp.Value);
}
return(await this.ReplaceStringWithSpecialModifiers(text, user, arguments, extraSpecialIdentifiers));
}
public async Task SendMessage(ChatMessageViewModel message)
{
if (!_chatCommandHandler.IsCommand(message.Message))
{
await SaveMessageToDatabase(message);
}
else
{
_chatCommandHandler.Execute(message.Message, (command, args) =>
{
if (command == "stock")
{
// send message to queue
_stockPriceQueueProducer.RequestStockPrice(args);
}
});
}
await Clients.All.SendAsync(ChatHubConstants.CLIENT_METHOD_NAME, message);
}
private async Task RunChatCommand(ChatMessageViewModel message, CommandModelBase command, IEnumerable <string> arguments)
{
Logger.Log(LogLevel.Debug, string.Format("Command Found For Message - {0} - {1} - {2}", message.ID, message, command));
CommandParametersModel parameters = new CommandParametersModel(message);
parameters.Arguments = new List <string>(arguments); // Overwrite arguments to account for variable argument length for commands
parameters.SpecialIdentifiers["message"] = message.PlainTextMessage;
await ChannelSession.Services.Command.Queue(command, parameters);
SettingsRequirementModel settings = command.Requirements.Settings;
if (settings != null)
{
if (settings != null && settings.ShouldChatMessageBeDeletedWhenRun)
{
await this.DeleteMessage(message);
}
}
}
public async Task DeleteMessage(ChatMessageViewModel message)
{
if (message.Platform == StreamingPlatformTypeEnum.Twitch)
{
if (!string.IsNullOrEmpty(message.ID))
{
await this.TwitchChatService.DeleteMessage(message);
}
}
if (!message.IsDeleted)
{
await message.Delete();
}
if (ChannelSession.Settings.HideDeletedMessages)
{
await this.RemoveMessage(message);
}
}
private async Task <bool> CheckForChatCommandAndRun(ChatMessageViewModel message, Dictionary <string, CommandModelBase> commands)
{
string[] messageParts = message.PlainTextMessage.Split(new char[] { ' ' });
for (int i = 0; i < messageParts.Length; i++)
{
string commandCheck = string.Join(" ", messageParts.Take(i + 1)).ToLower();
if (commandCheck.Length > this.longestTrigger)
{
return(false);
}
if (commands.ContainsKey(commandCheck))
{
await this.RunChatCommand(message, commands[commandCheck], messageParts.Skip(i + 1));
return(true);
}
}
return(false);
}
public async Task SendMessage(string message, int newsId)
{
string userName = Context.User.Identity.Name;
User user = await _userManager.FindByNameAsync(userName);
user.Avatar = _photoService.GetFileByID((int)user.AvatarId);
ChatMessage chatMessage = new ChatMessage()
{
Date = DateTime.Now,
Message = message,
User = user,
NewsId = newsId
};
_newsService.AddMessageChat(chatMessage);
ChatMessageViewModel chatMessageViewModel = _mapper.Map <ChatMessageViewModel>(chatMessage);
await Clients.Group(newsId.ToString()).SendAsync("ReceiveMessage", chatMessageViewModel);
}
private void HandleChatMessageFromClient(int connectionId, byte[] data)
{
try
{
//Creates a new instance of the buffer to read out the packet.
ByteBuffer buffer = new ByteBuffer();
//writes the packet into a list to make it avaiable to read it out.
buffer.WriteBytes(data);
//Todo INFO: You always have to read out the data as you sent it.
//In this case you always have to first to read out the packet identifier.
int packetIdentify = buffer.ReadInteger();
//In the server side you now send a string as next so you have to read out the string as next.
string chatJsonString = buffer.ReadString();
//todo: convert to chat model and Save this chat in the singleton
ChatMessageViewModel chatMessage = JsonConvert.DeserializeObject <ChatMessageViewModel>(chatJsonString);
//todo: remove this message later
string messageToDisplay = $"App ID: {chatMessage.AppId} Message: {chatMessage.Message} " +
$"User ID: {chatMessage.UserEmail} " +
$"Group Type: {Enum.GetName(typeof(GroupType), chatMessage.GroupType) } " +
$"Date: {DateTime.UtcNow}";
string messageJsonString = JsonConvert.SerializeObject(chatMessage);
//Send message to other clients
ServerTcp.SendChatMessageToClient(connectionId, messageJsonString);
//Save Chat Message
SaveChatMessage(chatMessage);
//print out the string msg you did send from the server.
Text.WriteLine($"Pckt ID: {packetIdentify} - Message: {chatMessage} ", TextType.INFO);
}
catch (Exception e)
{
Text.WriteLine($"Error occured in ServerHandleData:HandleChatMessageFromClient with message {e.Message}", TextType.ERROR);
}
}
public JsonResult getChatConversation(string otherUserId)
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
var currentUser = manager.FindById(User.Identity.GetUserId());
List<Message> messages = null;
using (ApplicationDbContext db = new ApplicationDbContext())
{
messages =
db.messages.Where(msg => (msg.fromUserId == otherUserId && msg.toUserId == currentUser.Id)
|| (msg.fromUserId == currentUser.Id && msg.toUserId == otherUserId)).ToList();
}
List<ChatMessageViewModel> resultList = new List<ChatMessageViewModel>();
foreach(Message m in messages)
{
ChatMessageViewModel tmp = new ChatMessageViewModel();
using (ApplicationDbContext db = new ApplicationDbContext())
{
tmp.fromId = m.fromUserId;
tmp.toId = m.toUserId;
tmp.content = m.content;
var user = db.Users.ToList().Find(u => u.Id == tmp.fromId);
tmp.fromUser = user.user;
tmp.imgPath = user.userImgPath;
tmp.toUser = db.Users.ToList().Find(u => u.Id == tmp.toId).user;
tmp.msgState = (currentUser.Id == tmp.fromId) ? "CurrentUser" : "notCurrentUser";
resultList.Add(tmp);
}
}
return Json(resultList);
}
private async void ContextMenuChatCommand_Click(object sender, RoutedEventArgs e)
{
if (this.ChatList.SelectedItem != null && this.ChatList.SelectedItem is ChatMessageViewModel)
{
ChatMessageViewModel message = (ChatMessageViewModel)this.ChatList.SelectedItem;
if (message.User != null)
{
if (e.Source is MenuItem)
{
MenuItem menuItem = (MenuItem)e.Source;
if (menuItem.DataContext != null && menuItem.DataContext is CommandModelBase)
{
CommandModelBase command = (CommandModelBase)menuItem.DataContext;
await ChannelSession.Services.Command.Queue(command, new CommandParametersModel(platform : message.Platform, arguments : new List <string>()
{
message.User.Username
}) { TargetUser = message.User });
}
}
}
}
}
private async void ContextMenuChatCommand_Click(object sender, RoutedEventArgs e)
{
if (this.ChatList.SelectedItem != null && this.ChatList.SelectedItem is ChatMessageViewModel)
{
ChatMessageViewModel message = (ChatMessageViewModel)this.ChatList.SelectedItem;
if (message.User != null)
{
if (e.Source is MenuItem)
{
MenuItem menuItem = (MenuItem)e.Source;
if (menuItem.DataContext != null && menuItem.DataContext is ChatCommand)
{
ChatCommand command = (ChatCommand)menuItem.DataContext;
await command.Perform(message.Platform, arguments : new List <string>()
{
message.User.Username
});
}
}
}
}
}
