public

nberardi / Poker.cs

Last active 2013-07-01

namespace Consensus.Hubs
{
	public class Poker : Hub
	{
		private static readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
		private static Dictionary<string, PokerUser> _users = new Dictionary<string, PokerUser>();
		private static List<PokerRoom> _rooms = new List<PokerRoom>();
 
		public PokerUser Join(PokerUser user)
		{
			_logger.Info("{0} joined consensus", user.Email);
 
			var userRef = _users.Where(x => x.Value.Email == user.Email).Select(x => new {
				ConnectionId = x.Key,
				User = x.Value
			}).FirstOrDefault();
 
			if (userRef != null && userRef.ConnectionId != Context.ConnectionId)
				_users.Remove(userRef.ConnectionId);
 
			user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault() ?? user;
 
			if (!_users.ContainsKey(Context.ConnectionId))
				_users.Add(Context.ConnectionId, user);
 
			return user;
		}
 
		public PokerRoom JoinRoom(PokerRoom room)
		{
			var user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault();
 
			if (user == null)
				throw new Exception("No user with this connection Id has joined yet.");
 
			_logger.Info("{0} joined {1} room", user.Email, room.Name);
 
			room = _rooms.FirstOrDefault(x => x.Name == room.Name) ?? room;
 
			if (!_rooms.Contains(room))
				_rooms.Add(room);
 
			if (room.Users.All(x => x.Email != user.Email)) {
				room.Users.Add(user);
			}
 
			// tell the people in this room that you've joined
			Clients.Group(room.Name).userChanged(user);
 
			Groups.Add(Context.ConnectionId, room.Name);
 
			return room;
		}
 
		private void AssertContextUserJoinedRoom(string roomName)
		{
			var user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault();
 
			if (user == null)
				throw new Exception("No user with this connection Id has joined yet.");
 
			var room = _rooms.FirstOrDefault(x => x.Name == roomName);
 
			if (room == null)
				throw new Exception("No room with this name exists.");
 
			if (room.Users.All(x => x.Email != user.Email)) {
				throw new Exception("User hasn't joined this room yet.");
			}
		}
 
		public void LeaveRoom(PokerRoom room, PokerUser user)
		{
			AssertContextUserJoinedRoom(room.Name);
			room = _rooms.FirstOrDefault(x => x.Name == room.Name);
 
			if (room.Users.All(x => x.Email != user.Email))
				throw new Exception("User being removed hasn't joined this room yet.");
 
			room.Users = room.Users.Where(x => x.Email != user.Email).ToList();
			room.Cards = room.Cards.Where(x => x.User.Email != user.Email).ToList();
 
			// tell the people in this room that user has been removed
			Clients.Group(room.Name).userRemoved(user);
		}
 
		public void ResetRoom(PokerRoom room)
		{
			AssertContextUserJoinedRoom(room.Name);
 
			room = _rooms.FirstOrDefault(x => x.Name == room.Name);
			room.Topic = "";
			room.Cards = new List<PokerCard>();
 
			// tell the people in this room that the topic has changed
			Clients.Group(room.Name).resetRoom(room);
		}
 
		public void ShowAllCards(PokerRoom room, bool show)
		{
			AssertContextUserJoinedRoom(room.Name);
 
			// tell the people in this room that the topic has changed
			Clients.Group(room.Name).showAllCards(show);
		}
 
		public void ChangeRoomTopic(PokerRoom room, string topic)
		{
			AssertContextUserJoinedRoom(room.Name);
 
			room = _rooms.FirstOrDefault(x => x.Name == room.Name);
			room.Topic = topic;
 
			// tell the people in this room that the topic has changed
			Clients.Group(room.Name).roomTopicChanged(topic);
		}
 
		public void ChangedCard(PokerRoom room, string cardValue)
		{
			AssertContextUserJoinedRoom(room.Name);
 
			var user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault();
			room = _rooms.FirstOrDefault(x => x.Name == room.Name);
 
			var card = room.Cards.FirstOrDefault(x => x.User.Email == user.Email);
 
			if (card == null) {
				card = new PokerCard {
					User = user,
					Value = cardValue
				};
				room.Cards.Add(card);
			}
 
			card.Value = cardValue;
 
			// tell the people in this room that your card has changed
			Clients.Group(room.Name).cardChanged(card);
		}
 
		public override Task OnDisconnected()
		{
			var user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault();
 
			if (user != null) {
				user.Disconnected = DateTimeOffset.UtcNow;
 
				// tell the people in this room that you've been disconnected
				foreach(var room in _rooms.Where(x => x.Users.Contains(user)))
					Clients.Group(room.Name).userChanged(user);
			}
 
			return base.OnDisconnected();
		}
	}
}

namespace Consensus.Models
{
	public class PokerCard
	{
		public PokerUser User { get; set; }
		public string Value { get; set; }
	}
}

namespace Consensus.Models
{
	public class PokerRoom
	{
		public PokerRoom()
		{
			Users = new List<PokerUser>();
			Cards = new List<PokerCard>();
		}
 
		public string Name { get; set; }
		public string Topic { get; set; }
 
		public virtual ICollection<PokerUser> Users { get; set; } 
		public virtual ICollection<PokerCard> Cards { get; set; } 
	}
}

namespace Consensus.Models
{
	public class PokerUser
	{
		public string Name { get; set; }
		public string Email { get; set; }
 
		public DateTimeOffset? Disconnected { get; set; }
	}
}

/// <reference path="typings/jquery/jquery.d.ts" />
/// <reference path="typings/signalr/signalr.d.ts" />
 
interface IPokerRoomClient {
	userChanged(user: Consensus.PokerUser);
	userRemoved(user: Consensus.PokerUser);
 
	resetRoom(room: Consensus.PokerRoom);
	showAllCards(show: boolean);
	roomTopicChanged(topic: string);
	cardChanged(card: Consensus.PokerCard);
}
 
interface IPokerRoomServer {
	join(user: Consensus.PokerUser): JQueryPromise;
	joinRoom(room: Consensus.PokerRoom): JQueryPromise;
	leaveRoom(room: Consensus.PokerRoom, user: Consensus.PokerUser): JQueryPromise;
 
	resetRoom(room: Consensus.PokerRoom): JQueryPromise;
	showAllCards(room: Consensus.PokerRoom, show: boolean): JQueryPromise;
	changeRoomTopic(room: Consensus.PokerRoom, topic: string): JQueryPromise;
	changedCard(room: Consensus.PokerRoom, value: string): JQueryPromise;
}
 
interface HubProxy {
	client: IPokerRoomClient;
	server: IPokerRoomServer;
}
 
interface SignalR {
	poker: HubProxy;
}
 
module Consensus {
	export class PokerUser {
		public Name: string;
		public Email: string;
		public Disconnected: string;
	}
 
	export class PokerRoom {
		public Name: string;
		public Topic: string;
		public Users: PokerUser[];
		public Cards: PokerCard[];
	}
 
	export class PokerCard {
		public User: PokerUser;
		public Value: string;
	}
}