public static void AddMessage(this ChatHubRoom room, ChatHubMessage message)
{
if (!room.Messages.Any(x => x.Id == message.Id))
{
room.Messages.Add(message);
}
}
public static void AddRoom(this List <ChatHubRoom> rooms, ChatHubRoom room)
{
if (!rooms.Any(x => x.Id == room.Id))
{
rooms.Add(room);
}
}
private async Task InitContextRoomAsync()
{
try
{
if (PageState.QueryString.ContainsKey("roomid"))
{
this.roomId = Int32.Parse(PageState.QueryString["roomid"]);
ChatHubRoom room = await this.ChatHubService.GetChatHubRoomAsync(roomId, ModuleState.ModuleId);
if (room != null)
{
this.title = room.Title;
this.content = room.Content;
this.type = room.Type;
this.imageUrl = room.ImageUrl;
this.createdby = room.CreatedBy;
this.createdon = room.CreatedOn;
this.modifiedby = room.ModifiedBy;
this.modifiedon = room.ModifiedOn;
}
else
{
await logger.LogError("Error Loading Room {ChatHubRoomId} {Error}", roomId);
ModuleInstance.AddModuleMessage("Error Loading ChatHub", MessageType.Error);
}
}
}
catch (Exception ex)
{
await logger.LogError(ex, "Error Loading Room {ChatHubRoomId} {Error}", roomId, ex.Message);
ModuleInstance.AddModuleMessage("Error Loading Room", MessageType.Error);
}
}
public async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
ChatHubRoom room = this.Rooms.FirstOrDefault(item => item.Id == message.ChatHubRoomId);
this.AddMessage(message, room);
this.UpdateUI();
}
public void AddMessage(ChatHubMessage message, ChatHubRoom room)
{
if (!room.Messages.Any(x => x.Id == message.Id))
{
room.Messages.Add(message);
}
}
public void AddRoom(ChatHubRoom room)
{
if (!this.Rooms.Any(x => x.Id == room.Id))
{
this.Rooms.Add(room);
}
}
public async Task <ChatHubRoom> CreateChatHubRoomClientModelAsync(ChatHubRoom room)
{
List <ChatHubMessage> lastMessages = new List <ChatHubMessage>();
if (room.OneVsOne())
{
lastMessages = await this.chatHubRepository.GetChatHubMessages(room.Id, new TimeSpan(24, 0, 0)).ToListAsync();
lastMessages = lastMessages != null && lastMessages.Any() ? lastMessages.Select(item => this.CreateChatHubMessageClientModel(item)).ToList() : new List <ChatHubMessage>();
}
List <ChatHubUser> onlineUsers = await this.chatHubRepository.GetOnlineUsers(room.Id).ToListAsync();
onlineUsers = onlineUsers != null && onlineUsers.Any() ? onlineUsers = onlineUsers.Select(item => this.CreateChatHubUserClientModel(item)).ToList() : new List <ChatHubUser>();
return(new ChatHubRoom()
{
Id = room.Id,
ModuleId = room.ModuleId,
Title = room.Title,
Content = room.Content,
ImageUrl = room.ImageUrl,
Type = room.Type,
Status = room.Status,
Messages = lastMessages,
Users = onlineUsers,
CreatedOn = room.CreatedOn,
CreatedBy = room.CreatedBy,
ModifiedBy = room.ModifiedBy,
ModifiedOn = room.ModifiedOn
});
}
public ChatHubRoom GetOneVsOneRoom(ChatHubUser callerUser, ChatHubUser targetUser, int moduleId)
{
if (callerUser != null && targetUser != null)
{
var oneVsOneRoom = this.chatHubRepository.GetChatHubRoomOneVsOne(this.CreateOneVsOneId(callerUser, targetUser));
if (oneVsOneRoom != null)
{
return(oneVsOneRoom);
}
ChatHubRoom chatHubRoom = new ChatHubRoom()
{
ModuleId = moduleId,
Title = string.Format("{0} vs {1}", callerUser.DisplayName, targetUser.DisplayName),
Content = "One Vs One",
Type = ChatHubRoomType.OneVsOne.ToString(),
Status = ChatHubRoomStatus.Active.ToString(),
ImageUrl = string.Empty,
OneVsOneId = this.CreateOneVsOneId(callerUser, targetUser)
};
return(this.chatHubRepository.AddChatHubRoom(chatHubRoom));
}
return(null);
}
public async Task EnableArchiveRoom(ChatHubRoom room)
{
try
{
if (room.Status == ChatHubRoomStatus.Archived.ToString())
{
room.Status = ChatHubRoomStatus.Enabled.ToString();
}
else if (room.Status == ChatHubRoomStatus.Enabled.ToString())
{
room.Status = ChatHubRoomStatus.Archived.ToString();
}
await ChatHubService.UpdateChatHubRoomAsync(room);
await logger.LogInformation("Room Archived {ChatHubRoom}", room);
NavigationManager.NavigateTo(NavigateUrl());
}
catch (Exception ex)
{
await logger.LogError(ex, "Error Archiving Room {ChatHubRoom} {Error}", room, ex.Message);
ModuleInstance.AddModuleMessage("Error Archiving Room", MessageType.Error);
}
}
public async Task SendMessage_Clicked(string messageInput, ChatHubRoom room)
{
await this.ChatHubService.SendMessage(messageInput, room.Id, ModuleState.ModuleId);
room.MessageInput = string.Empty;
this.StateHasChanged();
}
public async void KeyDown(KeyboardEventArgs e, ChatHubRoom room)
{
if (!e.ShiftKey && e.Key == "Enter")
{
this.SendMessage_Clicked(room.MessageInput, room);
}
}
public void ImportModule(Module module, string content, string version)
{
List <ChatHubRoom> chatHubs = null;
if (!string.IsNullOrEmpty(content))
{
chatHubs = JsonSerializer.Deserialize <List <ChatHubRoom> >(content);
}
if (chatHubs != null)
{
foreach (ChatHubRoom chatHubRoom in chatHubs)
{
ChatHubRoom room = new ChatHubRoom();
room.ModuleId = module.ModuleId;
room.Title = chatHubRoom.Title;
room.Content = chatHubRoom.Content;
room.BackgroundColor = chatHubRoom.BackgroundColor;
room.ImageUrl = chatHubRoom.ImageUrl;
room.Type = chatHubRoom.Type;
room.Status = chatHubRoom.Status;
room.OneVsOneId = chatHubRoom.OneVsOneId;
_chatHubRepository.AddChatHubRoom(room);
}
}
}
public static IList <ChatHubRoom> Swap <TItemGeneric>(this IList <ChatHubRoom> list, int x, int y)
{
ChatHubRoom temp = list[x];
list[x] = list[y];
list[y] = temp;
return(list);
}
public static void RemoveRoom(this List <ChatHubRoom> rooms, ChatHubRoom room)
{
var chatRoom = rooms.First(x => x.Id == room.Id);
if (chatRoom != null)
{
rooms.Remove(chatRoom);
}
}
public void RemoveRoom(ChatHubRoom room)
{
var chatRoom = this.Rooms.First(x => x.Id == room.Id);
if (chatRoom != null)
{
this.Rooms.Remove(chatRoom);
}
}
public ChatHubRoom UpdateChatHubRoom(ChatHubRoom ChatHubRoom)
{
try
{
db.Entry(ChatHubRoom).State = EntityState.Modified;
db.SaveChanges();
return(ChatHubRoom);
}
catch
{
throw;
}
}
public ChatHubRoom AddChatHubRoom(ChatHubRoom ChatHubRoom)
{
try
{
db.ChatHubRoom.Add(ChatHubRoom);
db.SaveChanges();
return(ChatHubRoom);
}
catch
{
throw;
}
}
public IQueryable <ChatHubModerator> GetChatHubModerators(ChatHubRoom ChatHubRoom)
{
try
{
return(db.Entry(ChatHubRoom)
.Collection(item => item.RoomModerators)
.Query().Select(item => item.Moderator));
}
catch
{
throw;
}
}
public IQueryable <ChatHubBlacklistUser> GetChatHubBlacklistUsers(ChatHubRoom ChatHubRoom)
{
try
{
return(db.Entry(ChatHubRoom)
.Collection(item => item.RoomBlacklistUsers)
.Query().Select(item => item.BlacklistUser));
}
catch
{
throw;
}
}
public async Task SaveRoom()
{
try
{
if (roomId == -1)
{
ChatHubRoom room = new ChatHubRoom()
{
ModuleId = ModuleState.ModuleId,
Title = this.title,
Content = this.content,
BackgroundColor = this.backgroundcolor,
Type = this.type,
Status = ChatHubRoomStatus.Enabled.ToString(),
ImageUrl = string.Empty,
OneVsOneId = string.Empty,
CreatorId = ChatHubService.ConnectedUser.UserId,
};
room = await this.ChatHubService.AddChatHubRoomAsync(room);
await logger.LogInformation("Room Added {ChatHubRoom}", room);
NavigationManager.NavigateTo(NavigateUrl());
}
else
{
ChatHubRoom room = await this.ChatHubService.GetChatHubRoomAsync(roomId, ModuleState.ModuleId);
if (room != null)
{
room.Title = this.title;
room.Content = this.content;
room.BackgroundColor = this.backgroundcolor;
room.Type = this.type;
await this.ChatHubService.UpdateChatHubRoomAsync(room);
await logger.LogInformation("Room Updated {ChatHubRoom}", room);
NavigationManager.NavigateTo(NavigateUrl());
}
}
}
catch (Exception ex)
{
await logger.LogError(ex, "Error Saving Room {ChatHubRoomId} {Error}", roomId, ex.Message);
ModuleInstance.AddModuleMessage("Error Saving Room", MessageType.Error);
}
}
public void DeleteChatHubRoom(int ChatHubRoomId, int ModuleId)
{
try
{
ChatHubRoom ChatHubRoom = db.ChatHubRoom.Where(item => item.Id == ChatHubRoomId)
.Where(item => item.ModuleId == ModuleId).FirstOrDefault();
db.ChatHubRoom.Remove(ChatHubRoom);
db.SaveChanges();
}
catch
{
throw;
}
}
public async Task <ChatHubRoom> CreateChatHubRoomClientModelAsync(ChatHubRoom room)
{
IList <ChatHubMessage> lastMessages = new List <ChatHubMessage>();
if (room.OneVsOne())
{
lastMessages = this.chatHubRepository.GetChatHubMessages(room.Id, 42);
lastMessages = lastMessages != null && lastMessages.Any() ? lastMessages.Select(item => this.CreateChatHubMessageClientModel(item)).ToList() : new List <ChatHubMessage>();
}
List <ChatHubUser> onlineUsers = await this.chatHubRepository.GetChatHubUsersByRoom(room).Online().ToListAsync();
onlineUsers = onlineUsers != null && onlineUsers.Any() ? onlineUsers = onlineUsers.Select(item => this.CreateChatHubUserClientModel(item)).ToList() : new List <ChatHubUser>();
IQueryable <ChatHubModerator> moderatorsQuery = this.chatHubRepository.GetChatHubModerators(room);
IList <ChatHubModerator> moderatorsList = await moderatorsQuery.ToListAsync();
IQueryable <ChatHubWhitelistUser> whitelistUsersQuery = this.chatHubRepository.GetChatHubWhitelistUsers(room);
IList <ChatHubWhitelistUser> whitelistUsersList = await whitelistUsersQuery.ToListAsync();
IQueryable <ChatHubBlacklistUser> blacklistUsersQuery = this.chatHubRepository.GetChatHubBlacklistUsers(room);
IList <ChatHubBlacklistUser> blacklistUsersList = await blacklistUsersQuery.ToListAsync();
ChatHubUser creator = await this.chatHubRepository.GetUserByIdAsync(room.CreatorId);
return(new ChatHubRoom()
{
Id = room.Id,
ModuleId = room.ModuleId,
Title = room.Title,
Content = room.Content,
BackgroundColor = room.BackgroundColor ?? "#999999",
ImageUrl = room.ImageUrl,
Type = room.Type,
Status = room.Status,
OneVsOneId = room.OneVsOneId,
CreatorId = room.CreatorId,
Creator = creator,
Messages = lastMessages,
Users = onlineUsers,
Moderators = moderatorsList,
WhitelistUsers = whitelistUsersList,
BlacklistUsers = blacklistUsersList,
CreatedOn = room.CreatedOn,
CreatedBy = room.CreatedBy,
ModifiedBy = room.ModifiedBy,
ModifiedOn = room.ModifiedOn
});
}
public async Task <ChatHubRoom> GetAsync(int id)
{
try
{
ChatHubRoom chatHubRoom = chatHubRepository.GetChatHubRoom(id);
ChatHubRoom chatHubRoomClientModel = await this.chatHubService.CreateChatHubRoomClientModelAsync(chatHubRoom);
return(chatHubRoomClientModel);
}
catch (Exception ex)
{
logger.Log(LogLevel.Error, this, LogFunction.Read, ex, "Get Error {Error}", ex.Message);
throw;
}
}
public bool IsWhitelisted(ChatHubRoom room, ChatHubUser caller)
{
var whitelistuser = this.chatHubRepository.GetChatHubWhitelistUser(caller.UserId);
if (whitelistuser != null)
{
var room_whitelistuser = this.chatHubRepository.GetChatHubRoomChatHubWhitelistUser(room.Id, whitelistuser.Id);
if (room_whitelistuser != null || caller.UserId == room.CreatorId)
{
return(true);
}
}
return(false);
}
public bool IsBlacklisted(ChatHubRoom room, ChatHubUser caller)
{
var blacklistuser = this.chatHubRepository.GetChatHubBlacklistUser(caller.UserId);
if (blacklistuser != null)
{
var room_blacklistuser = this.chatHubRepository.GetChatHubRoomChatHubBlacklistUser(room.Id, blacklistuser.Id);
if (room_blacklistuser != null)
{
return(true);
}
}
return(false);
}
public async Task SaveRoom()
{
try
{
if (roomId == -1)
{
ChatHubRoom room = new ChatHubRoom()
{
ModuleId = ModuleState.ModuleId,
Title = title,
Content = content,
Type = Enum.GetName(typeof(ChatHubRoomType), ChatHubRoomType.Public),
Status = Enum.GetName(typeof(ChatHubRoomStatus), ChatHubRoomStatus.Active),
ImageUrl = string.Empty,
OneVsOneId = string.Empty,
};
room = await this.ChatHubService.AddChatHubRoomAsync(room);
await logger.LogInformation("Room Added {ChatHubRoom}", room);
NavigationManager.NavigateTo(NavigateUrl());
}
else
{
ChatHubRoom room = await this.ChatHubService.GetChatHubRoomAsync(roomId, ModuleState.ModuleId);
if (room != null)
{
room.Title = title;
room.Content = content;
await this.ChatHubService.UpdateChatHubRoomAsync(room);
await logger.LogInformation("Room Updated {ChatHubRoom}", room);
NavigationManager.NavigateTo(NavigateUrl());
}
}
}
catch (Exception ex)
{
await logger.LogError(ex, "Error Saving Room {ChatHubRoomId} {Error}", roomId, ex.Message);
ModuleInstance.AddModuleMessage("Error Saving Room", MessageType.Error);
}
}
public async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
ChatHubRoom room = this.Rooms.FirstOrDefault(item => item.Id == message.ChatHubRoomId);
room.AddMessage(message);
if (message.ChatHubRoomId.ToString() != this.ContextRoomId)
{
this.Rooms.FirstOrDefault(room => room.Id == message.ChatHubRoomId).UnreadMessages++;
}
this.RunUpdateUI();
string elementId = string.Concat("#message-window-", this.ModuleId.ToString(), "-", message.ChatHubRoomId.ToString());
await this.ScrollService.ScrollToBottom(elementId);
}
public void UserlistItem_Clicked(MouseEventArgs e, ChatHubRoom room, ChatHubUser user)
{
if (user.UserlistItemCollapsed)
{
user.UserlistItemCollapsed = false;
}
else
{
foreach (var chatUser in room.Users.Where(x => x.UserlistItemCollapsed == true))
{
chatUser.UserlistItemCollapsed = false;
}
user.UserlistItemCollapsed = true;
}
this.UpdateUIStateHasChanged();
}
private async Task AddWaitingRoomItem(ChatHubUser user, ChatHubRoom room)
{
var chatHubWaitingRoomItem = new ChatHubWaitingRoomItem()
{
Guid = Guid.NewGuid(),
RoomId = room.Id,
UserId = user.UserId,
DisplayName = user.DisplayName
};
var roomCreator = await this.chatHubRepository.GetUserByIdAsync(room.CreatorId);
foreach (var connection in roomCreator.Connections.Active())
{
await Clients.Client(connection.ConnectionId).SendAsync("AddWaitingRoomItem", chatHubWaitingRoomItem);
}
}
public async Task <ChatHubRoom> PutAsync(int id, [FromBody] ChatHubRoom ChatHubRoom)
{
try
{
if (ModelState.IsValid && ChatHubRoom.ModuleId == EntityId)
{
ChatHubRoom = chatHubRepository.UpdateChatHubRoom(ChatHubRoom);
logger.Log(LogLevel.Information, this, LogFunction.Update, "ChatHubRoom Updated {ChatHubRoom}", ChatHubRoom);
}
return(await this.chatHubService.CreateChatHubRoomClientModelAsync(ChatHubRoom));
}
catch (Exception ex)
{
logger.Log(LogLevel.Error, this, LogFunction.Update, ex, "Put Error {Error}", ex.Message);
throw;
}
}
