public static void EnsureAllowed(this ChatUser user, ChatRoom room) { if (room.Private && !room.IsUserAllowed(user)) { throw new InvalidOperationException("You do not have access to " + room.Name); } }
public void MakesOwnerAllowedIfRoomLocked() { var repository = new InMemoryRepository(); var user = new ChatUser { Name = "foo" }; var user2 = new ChatUser { Name = "foo2" }; repository.Add(user); repository.Add(user2); var room = new ChatRoom { Name = "Room", Creator = user, Private = true }; room.Owners.Add(user); user.OwnedRooms.Add(room); user.Rooms.Add(room); room.Users.Add(user); var service = new ChatService(repository, new Mock<ICryptoService>().Object); service.AddOwner(user, user2, room); Assert.True(user2.AllowedRooms.Contains(room)); Assert.True(room.AllowedUsers.Contains(user2)); Assert.True(room.Owners.Contains(user2)); Assert.True(user2.OwnedRooms.Contains(room)); }
public void AddOwner(ChatUser ownerOrCreator, ChatUser targetUser, ChatRoom targetRoom) { // Ensure the user is owner of the target room EnsureOwner(ownerOrCreator, targetRoom); if (targetRoom.Owners.Contains(targetUser)) { // If the target user is already an owner, then throw throw new InvalidOperationException(String.Format("'{0}' is already and owner of '{1}'.", targetUser.Name, targetRoom.Name)); } // Make the user an owner targetRoom.Owners.Add(targetUser); targetUser.OwnedRooms.Add(targetRoom); if (targetRoom.Private) { if (!targetRoom.AllowedUsers.Contains(targetUser)) { // If the room is private make this user allowed targetRoom.AllowedUsers.Add(targetUser); targetUser.AllowedRooms.Add(targetRoom); } } }
public static void EnsureAllowed(this ChatUser user, ChatRoom room) { if (room.Private && !room.IsUserAllowed(user)) { throw new HubException(String.Format(LanguageResources.RoomAccessPermission, room.Name)); } }
public static void SetUserInRoom(this ICache cache, ChatUser user, ChatRoom room, bool value) { string key = CacheKeys.GetUserInRoom(user, room); // Cache this forever since people don't leave rooms often cache.Set(key, value, TimeSpan.FromDays(365)); }
public void MakesUserOwner() { var repository = new InMemoryRepository(); var user = new ChatUser { Name = "foo" }; var user2 = new ChatUser { Name = "foo2" }; repository.Add(user); repository.Add(user2); var room = new ChatRoom { Name = "Room", Creator = user }; room.Owners.Add(user); user.OwnedRooms.Add(room); user.Rooms.Add(room); room.Users.Add(user); var service = new ChatService(repository); service.AddOwner(user, user2, room); Assert.True(room.Owners.Contains(user2)); Assert.True(user2.OwnedRooms.Contains(room)); }
public IJabbrRepository CreateRoomRepository() { var repository = new InMemoryRepository(); var room = new ChatRoom() { Name = "hashtag" }; var user = new ChatUser() { Name = "testhashtaguser" }; repository.Add(room); room.Users.Add(user); user.Rooms.Add(room); return repository; }
public static bool IsUserInRoom(this IJabbrRepository repository, ICache cache, ChatUser user, ChatRoom room) { bool? cached = cache.IsUserInRoom(user, room); if (cached == null) { cached = repository.IsUserInRoom(user, room); cache.SetUserInRoom(user, room, cached.Value); } return cached.Value; }
public ChatMessage AddMessage(ChatUser user, ChatRoom room, string content) { var chatMessage = new ChatMessage { Id = Guid.NewGuid().ToString("d"), User = user, Content = content, When = DateTimeOffset.UtcNow, Room = room }; _repository.Add(chatMessage); return chatMessage; }
public void AddsNewMessageToRepository() { var repository = new InMemoryRepository(); var user = new ChatUser { Name = "foo" }; repository.Add(user); var room = new ChatRoom { Name = "Room" }; repository.Add(room); room.Users.Add(user); user.Rooms.Add(room); var service = new ChatService(new Mock<ICache>().Object, repository, new Mock<ICryptoService>().Object); ChatMessage message = service.AddMessage(user, room, Guid.NewGuid().ToString(), "Content"); Assert.NotNull(message); Assert.Same(message, room.Messages.First()); Assert.Equal("Content", message.Content); }
public void AddsNewMessageToRepository() { var repository = new InMemoryRepository(); var user = new ChatUser { Name = "foo" }; repository.Add(user); var room = new ChatRoom { Name = "Room" }; repository.Add(room); room.Users.Add(user); user.Rooms.Add(room); var service = new ChatService(repository); ChatMessage message = service.AddMessage(user, room, "Content"); Assert.NotNull(message); Assert.Same(message, room.Messages.First()); Assert.Equal("Content", message.Content); }
internal static bool IsUserInRoom(ChatRoom room, ChatUser user) { return room.Users.Any(r => r.Name.Equals(user.Name, StringComparison.OrdinalIgnoreCase)); }
public void SetInviteCode(ChatUser user, ChatRoom room, string inviteCode) { EnsureOwner(user, room); if (!room.Private) { throw new InvalidOperationException("Only private rooms can have invite codes"); } // Set the invite code and save room.InviteCode = inviteCode; _repository.CommitChanges(); }
public void OpenRoom(ChatUser user, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (!targetRoom.Closed) { throw new InvalidOperationException(string.Format("{0} is already open.", targetRoom.Name)); } // Open the room targetRoom.Closed = false; _repository.CommitChanges(); }
public void LeaveRoom(ChatUser user, ChatRoom room) { // Remove the user from the room room.Users.Remove(user); // Remove this room from the users' list user.Rooms.Remove(room); }
public void JoinRoom(ChatUser user, ChatRoom room, string inviteCode) { // Throw if the room is private but the user isn't allowed if (room.Private) { // First, check if the invite code is correct if (!String.IsNullOrEmpty(inviteCode) && String.Equals(inviteCode, room.InviteCode, StringComparison.OrdinalIgnoreCase)) { // It is, add the user to the allowed users so that future joins will work room.AllowedUsers.Add(user); } if (!IsUserAllowed(room, user)) { throw new InvalidOperationException(String.Format("Unable to join {0}. This room is locked and you don't have permission to enter. If you have an invite code, make sure to enter it in the /join command", room.Name)); } } // Add this room to the user's list of rooms user.Rooms.Add(room); // Add this user to the list of room's users room.Users.Add(user); }
public void ChangeTopic(ChatUser user, ChatRoom room, string newTopic) { EnsureOwner(user, room); room.Topic = newTopic; _repository.CommitChanges(); }
public ChatRoom AddRoom(ChatUser user, string name) { if (name.Equals("Lobby", StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException("Lobby is not a valid chat room."); } if (!IsValidRoomName(name)) { throw new InvalidOperationException(String.Format("'{0}' is not a valid room name.", name)); } var room = new ChatRoom { Name = name, Creator = user }; room.Owners.Add(user); _repository.Add(room); user.OwnedRooms.Add(room); return room; }
public void AddUserRoom(ChatUser user, ChatRoom room) { user.Rooms.Add(room); room.Users.Add(user); }
public void RemoveUserRoom(ChatUser user, ChatRoom room) { user.Rooms.Remove(room); room.Users.Remove(user); }
public void Remove(ChatRoom room) { _rooms.Remove(room); }
public void Add(ChatRoom room) { _rooms.Add(room); }
public static bool IsUserInRoom(this IJabbrRepository repository, ICache cache, ChatUser user, ChatRoom room) { bool?cached = cache.IsUserInRoom(user, room); if (cached == null) { cached = repository.IsUserInRoom(user, room); cache.SetUserInRoom(user, room, cached.Value); } return(cached.Value); }
public void Add(ChatRoom room) { _db.Rooms.Add(room); _db.SaveChanges(); }
private void OnUpdateActivity(ChatUser user, ChatRoom room) { var userViewModel = new UserViewModel(user); Clients[room.Name].updateActivity(userViewModel, room.Name); }
public bool IsUserInRoom(ChatUser user, ChatRoom room) { // REVIEW: Inefficient, bu only users for unit tests right now return(room.Users.Any(u => u.Name == user.Name)); }
public void AllowUser(ChatUser user, ChatUser targetUser, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (!targetRoom.Private) { throw new InvalidOperationException(String.Format("{0} is not a private room.", targetRoom.Name)); } if (targetUser.AllowedRooms.Contains(targetRoom)) { throw new InvalidOperationException(String.Format("{0} is already allowed for {1}.", targetUser.Name, targetRoom.Name)); } targetRoom.AllowedUsers.Add(targetUser); targetUser.AllowedRooms.Add(targetRoom); _repository.CommitChanges(); }
public IQueryable <ChatUser> GetOnlineUsers(ChatRoom room) { return(room.Users.Online().AsQueryable()); }
public void CloseRoom(ChatUser user, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (targetRoom.Closed) { throw new InvalidOperationException(String.Format("{0} is already closed.", targetRoom.Name)); } // Make sure the (owner) user is not in the room. if (targetRoom.Users.Contains(user)) { throw new InvalidOperationException("You are trying to close a room which you are still in. Please leave the room before closing it."); } // Kick all existing users in the room. foreach (var targetUser in targetRoom.Users.ToList()) { LeaveRoom(targetUser, targetRoom); } // Make the room closed. targetRoom.Closed = true; _repository.CommitChanges(); }
private static void EnsureOwner(ChatUser user, ChatRoom room) { if (!room.Owners.Contains(user)) { throw new InvalidOperationException("You are not an owner of room '" + room.Name + "'"); } }
public void KickUser(ChatUser user, ChatUser targetUser, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (targetUser == user) { throw new InvalidOperationException("Why would you want to kick yourself?"); } if (!IsUserInRoom(targetRoom, targetUser)) { throw new InvalidOperationException(String.Format("'{0}' isn't in '{1}'.", targetUser.Name, targetRoom.Name)); } // If this user isnt' the creator and the target user is an owner then throw if (targetRoom.Creator != user && targetRoom.Owners.Contains(targetUser)) { throw new InvalidOperationException("Owners cannot kick other owners. Only the room creator and kick an owner."); } LeaveRoom(targetUser, targetRoom); }
public void AddUserRoom(ChatUser user, ChatRoom room) { RunNonLazy(() => room.Users.Add(user)); }
public void LockRoom(ChatUser user, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (targetRoom.Private) { throw new InvalidOperationException(String.Format("{0} is already locked.", targetRoom.Name)); } // Make the room private targetRoom.Private = true; // Add the creator to the allowed list targetRoom.AllowedUsers.Add(user); // Add the room to the users' list user.AllowedRooms.Add(targetRoom); // Make all users in the current room allowed foreach (var u in targetRoom.Users.Online()) { u.AllowedRooms.Add(targetRoom); targetRoom.AllowedUsers.Add(u); } _repository.CommitChanges(); }
public IQueryable <ChatMessage> GetMessagesByRoom(ChatRoom room) { return(room.Messages.AsQueryable()); }
public void RemoveOwner(ChatUser creator, ChatUser targetUser, ChatRoom targetRoom) { // Ensure the user is creator of the target room EnsureCreator(creator, targetRoom); if (!targetRoom.Owners.Contains(targetUser)) { // If the target user is not an owner, then throw throw new InvalidOperationException(String.Format("'{0}' is not an owner of '{1}'.", targetUser.Name, targetRoom.Name)); } // Remove user as owner of room targetRoom.Owners.Remove(targetUser); targetUser.OwnedRooms.Remove(targetRoom); }
private void LeaveRoom(ChatUser user, ChatRoom room) { var userViewModel = new UserViewModel(user); Clients[room.Name].leave(userViewModel, room.Name).Wait(); foreach (var client in user.ConnectedClients) { Groups.Remove(client.Id, room.Name).Wait(); } OnRoomChanged(room); }
public void UnallowUser(ChatUser user, ChatUser targetUser, ChatRoom targetRoom) { EnsureOwner(user, targetRoom); if (targetUser == user) { throw new InvalidOperationException("Why would you want to unallow yourself?"); } if (!targetRoom.Private) { throw new InvalidOperationException(String.Format("{0} is not a private room.", targetRoom.Name)); } if (!targetUser.AllowedRooms.Contains(targetRoom)) { throw new InvalidOperationException(String.Format("{0} isn't allowed to access {1}.", targetUser.Name, targetRoom.Name)); } // If this user isn't the creator and the target user is an owner then throw if (targetRoom.Creator != user && targetRoom.Owners.Contains(targetUser)) { throw new InvalidOperationException("Owners cannot unallow other owners. Only the room creator and unallow an owner."); } targetRoom.AllowedUsers.Remove(targetUser); targetUser.AllowedRooms.Remove(targetRoom); // Make the user leave the room LeaveRoom(targetUser, targetRoom); _repository.CommitChanges(); }
private void OnRoomChanged(ChatRoom room) { var roomViewModel = new RoomViewModel { Name = room.Name, Private = room.Private, Closed = room.Closed }; // Update the room count Clients.updateRoomCount(roomViewModel, _repository.GetOnlineUsers(room).Count()); }
private static void EnsureCreator(ChatUser user, ChatRoom room) { if (user != room.Creator) { throw new InvalidOperationException("You are not the creator of " + room.Name); } }
public void Remove(ChatRoom room) { _db.Rooms.Remove(room); _db.SaveChanges(); }
private bool IsUserAllowed(ChatRoom room, ChatUser user) { return room.AllowedUsers.Contains(user); }
public IQueryable <ChatMessage> GetMessagesByRoom(ChatRoom room) { return(_db.Messages.Include(r => r.User).Where(r => r.RoomKey == room.Key)); }