public void GroupChatMessage_Constructor()
{
var user = FakeObjects.TestUserWithId();
var group = FakeObjects.TestProjectWithId();
var timestamp = DateTime.UtcNow;
var groupChatMessage = new GroupChatMessage(
user,
group,
user,
timestamp,
FakeValues.Message
);
Assert.AreEqual(groupChatMessage.GroupId, group.Id);
Assert.AreEqual(groupChatMessage.Message, FakeValues.Message);
Assert.AreEqual(groupChatMessage.TargetUser, user.DenormalisedUserReference());
Assert.AreEqual(groupChatMessage.Timestamp, timestamp);
}
public async void AddMessage(string inputMessage)
{
var user = inputMessage.Split(':')[0];
var message = inputMessage.Skip(user.Length);
var userModel = await _context.Users.FirstOrDefaultAsync(x => x.Login == message);
var companyModel = await _context.Companies.FirstOrDefaultAsync(x => x.Users == userModel);
GroupChatMessage newMessage = new GroupChatMessage
{
UserID = userModel.ID,
CompanyID = companyModel.ID,
Text = inputMessage,
CreationDate = DateTime.Now
};
await _context.GroupChatMessages.AddAsync(newMessage);
await _context.SaveChangesAsync();
}
public async Task DeleteGroupMessage(int msgId, int chatId)
{
repository.DeleteGroupChatMessage(msgId);
await Clients.All.SendAsync("DeleteGroupMsgChat", msgId, chatId);
GroupChat chat = repository.GroupChats.FirstOrDefault(c => c.ChatId == chatId);
string chatPhoto = (chat.ChatPhotoPath != null) ?
$"/UsersData/{chat.ChatPhotoPath}" : "/defaultGroup.png";
GroupChatMessage lastMsg = repository.GroupChatMessages.LastOrDefault(m => m.GroupChatId == chatId);
AppUser sender = userManager.Users.FirstOrDefault(u => u.Id == lastMsg.UserId);
string senderPhoto = (sender.ProfilePhotoUrl != null) ?
$"/UsersData/{sender.ProfilePhotoUrl}" : "/defaultAvatar.png";
string senderName = (sender.FirstName == null && sender.LastName == null) ?
sender.UserName : $"{sender.FirstName} {sender.LastName}";
foreach (GroupChatUsers user in repository.GroupChatUsers.Where(u => u.GroupChatId == chatId))
{
int userUnseenMsgs = 0;
foreach (GroupChatMessage msg in repository.GroupChatMessages
.Where(m => m.GroupChatId == chat.ChatId))
{
if (msg.UserId != user.UserId)
{
if (repository.GroupMessageViews.Any(m => m.MessageId == msg.MessageId &&
m.UserId == user.UserId) == false)
{
userUnseenMsgs++;
}
}
}
await Clients.All.SendAsync("ChatIndexNewLastGroupMsg", sender.Id, user.UserId,
chat.ChatId, senderName, DateTime.Now.ToShortTimeString(), lastMsg.MessageContent,
userUnseenMsgs, chatPhoto, chat.Title);
await Clients.All.SendAsync("UserHeaderNewLastGroupMsg", sender.Id, user.UserId,
chat.ChatId, senderName, DateTime.Now.ToShortTimeString(), lastMsg.MessageContent,
userUnseenMsgs, chatPhoto, chat.Title);
}
}
public void GroupMessage(string groupName, string message)
{
using (UnitOfWork uow = new UnitOfWork())
{
//Clients.Group(groupName).showBroadcastMessage(message);
Clients.Group(groupName).showGroupMessage(groupName, message);
var room = uow.FindObject <GroupChat>(CriteriaOperator.Parse("RoomName==?", groupName));
if (room != null)
{
var msg = new GroupChatMessage(uow)
{
Message = message,
SenderUserName = Context.User.Identity.Name,
Timestamp = DateTime.Now
};
room.GroupChatMessages.Add(msg);
uow.CommitChanges();
}
}
}
public async Task <GetGroupChatMessageDto> AddMessageAsync(CreateGroupChatMessageDto messageDto, CancellationToken ct = default)
{
_logger.LogInformation("Create group chat message {GroupChatMessage}", messageDto);
GroupChat chat = await _unitOfWork.GroupChatRepository.GetAsync(messageDto.ChatId, ct);
if (chat == null)
{
_logger.LogWarning("Group chat with id {GroupChatId} not found", messageDto.ChatId);
throw new ChatNotFoundException();
}
GroupChatMessage message = _mapper.Map <GroupChatMessage>(messageDto);
message.CreatedAt = message.UpdatedAt = DateTime.UtcNow;
_unitOfWork.GroupChatMessageRepository.Create(message);
await _unitOfWork.CommitAsync(ct);
return(_mapper.Map <GetGroupChatMessageDto>(message));
}
public async Task <ViewResult> Index(string id)
{
ViewData["Id"] = id;
AppUser user = userManager.Users.FirstOrDefault(u => u.Id == id);
IQueryable <AppUser> users = userManager.Users
.Where(u => u.CompanyName == user.CompanyName ||
u.CompanyName == null || u.CompanyName == "" && u.Id != id);
if (user.CompanyName == null || user.CompanyName == "")
{
users = userManager.Users
.Where(u => u.Id != id);
}
List <HeaderChatViewModel> chats = new List <HeaderChatViewModel>();
int totalNewMsg = 0;
foreach (Chat chat in repository.Chats)
{
if (chat.User1Id == id || chat.User2Id == id)
{
if (chat.Messages.LastOrDefault() != null)
{
int unseenMsg = chat.Messages
.Where(m => m.Seen == false && m.UserId != id).Count();
totalNewMsg += unseenMsg;
HeaderChatViewModel ci = new HeaderChatViewModel
{
GroupChat = false,
chat = chat,
LastMessage = chat.Messages.LastOrDefault(),
LastMessageDate = chat.Messages.LastOrDefault().DateAdded,
UnseenMsg = unseenMsg
};
chats.Add(ci);
}
}
}
foreach (GroupChat groupChat in repository.GroupChats.Where(g => g.Status == "Public"))
{
if (repository.GroupChatUsers.FirstOrDefault(g => g.GroupChatId == groupChat.ChatId &&
g.UserId == user.Id) != null)
{
GroupChatMessage lastMsg = repository.GroupChatMessages
.LastOrDefault(m => m.GroupChatId == groupChat.ChatId);
if (lastMsg != null)
{
int totalMsg = 0;
foreach (GroupChatMessage msg in repository.GroupChatMessages
.Where(m => m.GroupChatId == groupChat.ChatId))
{
if (msg.UserId != user.Id)
{
if (repository.GroupMessageViews.Any(m => m.MessageId == msg.MessageId &&
m.UserId == user.Id) == false)
{
totalMsg++;
totalNewMsg++;
}
}
}
HeaderChatViewModel ci = new HeaderChatViewModel
{
GroupChat = true,
GChat = groupChat,
LastGroupMessage = lastMsg,
LastMessageDate = lastMsg.DateAdded,
UnseenMsg = totalMsg
};
chats.Add(ci);
}
}
}
return(View(new FullChatViewModel
{
Chats = chats.AsQueryable().OrderByDescending(c => c.LastMessageDate),
TotalNewMessages = totalNewMsg,
Users = users
}));
}
public void NewOutgoingMessage( string msg )
{
GroupChatMessage m = new GroupChatMessage(this.Room, msg);
_sm.SendAndForget(m);
}
/// <summary>
/// Static method that takes in an xml String and converts it to an AbstractMessage.
///
/// Will throw an XmlException if the xml String was in an unrecognized format.
/// </summary>
/// <param name="xml">A String with xml representing an AbstractMessage</param>
/// <returns>The AbstractMessage parsed from the XML String</returns>
public override AbstractMessage Parse(String xml)
{
XmlTextReader reader = new XmlTextReader(new StringReader(xml));
AbstractMessage returnee = null;
Int32 chatId = 0;
String element = "";
String textMessage = "";
String username = "";
String password = "";
String sender = "";
Boolean accepted = false;
Boolean isAlreadyLoggedOn = true;
Boolean alreadyExisted = false;
Boolean authenticationDisabled = false;
GroupChat chat = null;
ExtendedHashSet<String> hashSet = null;
try
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
switch (element)
{
case "Message":
textMessage = reader.Value;
break;
case "Username":
username = reader.Value;
break;
case "Password":
password = reader.Value;
break;
case "User":
hashSet.Add(reader.Value);
break;
case "Participant":
hashSet.Add(reader.Value);
break;
case "Sender":
sender = reader.Value;
break;
case "Name":
hashSet.Add(reader.Value);
break;
default:
break;
}
break;
case XmlNodeType.Element:
element = reader.Name; // define last known element
switch (element)
{
case "UserList":
hashSet = new ExtendedHashSet<String>();
break;
case "Participants":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeAdded":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeRemoved":
hashSet = new ExtendedHashSet<String>();
break;
}
break;
case XmlNodeType.EndElement:
switch (reader.Name)
{
case "TextMessage":
returnee = new TextMessage(textMessage);
break;
case "LoginMessage":
returnee = new LoginMessage(username, password);
break;
case "LoginResponseMessage":
returnee = new LoginResponseMessage(accepted, isAlreadyLoggedOn, username);
break;
case "AddToUserListMessage":
returnee = new AddToUserListMessage(hashSet);
break;
case "RemoveFromUserListMessage":
returnee = new RemoveFromUserListMessage(hashSet);
break;
case "GroupChatMessage":
returnee = new GroupChatMessage(chat, textMessage, sender);
break;
case "AddMemberToGroupChatMessage":
returnee = new AddMemberToGroupChatMessage(chatId, hashSet);
break;
case "RemoveMemberFromGroupChatMessage":
returnee = new RemoveMemberFromGroupChatMessage(chatId, hashSet);
break;
case "StartGroupChatRequestMessage":
returnee = new StartGroupChatRequestMessage(hashSet);
break;
case "StartGroupChatResponseMessage":
returnee = new StartGroupChatResponseMessage(chatId, alreadyExisted);
break;
case "GroupChatInfoRequestMessage":
returnee = new GroupChatInfoRequestMessage(chatId);
break;
case "GroupChatInfoResponseMessage":
returnee = new GroupChatInfoResponseMessage(chat);
break;
case "SignupRequestMessage":
returnee = new SignupRequestMessage(username, password);
break;
case "SignupResponseMessage":
returnee = new SignupResponseMessage(accepted, alreadyExisted, authenticationDisabled);
break;
case "GroupChat":
chat = new GroupChat(hashSet, chatId);
break;
default:
break;
}
break;
case XmlNodeType.Text:
switch (element)
{
case "Accepted":
accepted = Boolean.Parse(reader.Value);
break;
case "IsAlreadyLoggedOn":
isAlreadyLoggedOn = Boolean.Parse(reader.Value);
break;
case "ChatID":
chatId = int.Parse(reader.Value);
break;
case "AlreadyExisted":
alreadyExisted = Boolean.Parse(reader.Value);
break;
case "AuthenticationDisabled":
authenticationDisabled = Boolean.Parse(reader.Value);
break;
default:
break;
}
break;
default:
break;
}
}
}
catch
{
throw new XmlException("Unrecognized XML Format...");
}
reader.Close();
if (returnee != null)
{
return returnee;
}
else
{
throw new XmlException("Unrecognized XML Format...");
}
}
public async Task <IActionResult> NewGroupStep3(NewGroupStep3ViewModel model)
{
ViewData["Id"] = model.UserId;
AppUser user = await userManager.FindByIdAsync(model.UserId);
if (user != null)
{
//group
Group group = repository.Groups
.FirstOrDefault(g => g.GroupId == model.GroupId);
if (model.CoursesIdString != null)
{
//list of users id
string courseIdList = model.CoursesIdString.Trim();
while (courseIdList.Trim().Length > 0)
{
int index = courseIdList.IndexOf(";");
if (index != -1)
{
string newCourseId = courseIdList.Substring(0, index);
int newCourseIdInt = Int32.Parse(newCourseId.Trim());
repository.AddCourseToGroup(newCourseIdInt, group.GroupId);
courseIdList = courseIdList.Replace(newCourseId + ";", "");
}
}
}
//send msg
if (group.GroupChatId != 0)
{
GroupChat groupChat = repository.GroupChats
.FirstOrDefault(g => g.ChatId == group.GroupChatId);
string userName = (user.FirstName == null && user.LastName == null) ?
user.UserName : user.FirstName + user.LastName;
string content = $"{userName} created a group chat";
GroupChatMessage newMsg = new GroupChatMessage
{
GroupChatId = group.GroupChatId,
UserId = user.Id,
MessageContent = content,
MessageType = "SystemMsg"
};
repository.NewGroupChatMessage(newMsg, groupChat);
}
//new notification
if (group.Status == "Public")
{
repository.NewNotification(user.Id, "AddUserToGroup", "Group", group.GroupId);
}
return(RedirectToAction("GroupDetails", new
{
id = group.CreatedBy.Id,
groupId = group.GroupId
}));
}
return(RedirectToAction("Error", "UserNotFound"));
}
public async Task Invoke(HttpContext context, EnterChatContext chatContext)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await _next.Invoke(context);
return;
}
CancellationToken ct = context.RequestAborted;
WebSocket currentSocket = await context.WebSockets.AcceptWebSocketAsync();
var socketId = Guid.NewGuid().ToString();
_sockets.TryAdd(socketId, currentSocket);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var response = await ReceiveStringAsync(currentSocket, ct);
if (string.IsNullOrEmpty(response))
{
if (currentSocket.State != WebSocketState.Open)
{
break;
}
continue;
}
int user_id = Int32.Parse(context.User.FindFirst(ClaimTypes.NameIdentifier).Value);
int comp_id = Int32.Parse(context.User.FindFirst("CompanyID").Value);
User user = await chatContext.Users.Where(u => u.ID == user_id).FirstOrDefaultAsync();
Worker worker = await chatContext.Workers.Where(w => w.ID == user.WorkerID).FirstOrDefaultAsync();
int index_stick = response.IndexOf('|');
string idRaw = response.Substring(0, index_stick);
string trueMessage = response.Remove(0, index_stick + 1);
if (idRaw.Equals("NoN"))
{
GroupChatMessage message = new GroupChatMessage
{
UserID = user_id,
CompanyID = comp_id,
Text = trueMessage,
CreationDate = DateTime.Now
};
await chatContext.GroupChatMessages.AddAsync(message);
await chatContext.SaveChangesAsync();
}
else
{
TopicMessage topicMessage = new TopicMessage
{
TopicID = Convert.ToInt32(idRaw),
UserID = user_id,
CompanyID = comp_id,
Text = trueMessage,
CreationDate = DateTime.Now
};
await chatContext.TopicMessages.AddAsync(topicMessage);
await chatContext.SaveChangesAsync();
}
string responceMessage = worker.FirstName + " " + worker.SecondName + ": " + trueMessage;
foreach (var socket in _sockets)
{
if (socket.Value.State != WebSocketState.Open)
{
continue;
}
await SendStringAsync(socket.Value, responceMessage, ct);
}
}
WebSocket dummy;
_sockets.TryRemove(socketId, out dummy);
await currentSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", ct);
currentSocket.Dispose();
}
