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));
}
