public void DealCardsTest()
{
//Arrange
GameController gameController = new GameController();
ICGUserDBIF cGUserDB = new CGUserDB();
IDeckDBIF deckDB = new DeckDB();
ICardDBIF cardDB = new CardDB();
UserManagement userManagement = new UserManagement();
List <CardModel> cardModels = (List <CardModel>)cardDB.GetAll();
List <Card> cards = CardConverter.ConvertFromListOfCardModelToListOfCard(cardModels);
Deck deck = DeckConverter.ConvertFromDeckModelToDeck(deckDB.GetById(2));
List <CGUser> users = new List <CGUser>();
CGUser user = CGUserConverter.convertFromCGUserModelToCGUser(cGUserDB.GetById("Test"));
users.Add(user);
userManagement.DeleteHand(user);
//Act
gameController.DealCards(deck, users);
List <Card> userCards = user.cards;
//Assert
Assert.IsTrue(userCards.Count > 0);
//Cleanup
userManagement.DeleteHand(user);
}
public void InsertHandTest()
{
//Arrange
cgUserDB = new CGUserDB();
CardDB cardDB = new CardDB();
//Act
var userModel = cgUserDB.GetById("Test");
List <CardModel> cardsOnHand = cardDB.GetCardsByDeckId(2);
List <CardModel> filteredCardsOnHand = new List <CardModel>();
for (int i = 0; i < 5; i++)
{
CardModel card = cardsOnHand[i];
filteredCardsOnHand.Add(card);
}
cgUserDB.InsertHand(filteredCardsOnHand, userModel);
CGUser user = CGUserConverter.convertFromCGUserModelToCGUser(cgUserDB.GetById("Test"));
//Assert
Assert.IsTrue(user.cards.Count > 0);
//CleanUp
CGUserModel revertedUser = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
cgUserDB.DeleteHand(revertedUser);
}
public bool DeleteCGUser(CGUserModel user)
{
using (UserManagementServiceClient proxy = new UserManagementServiceClient()) {
CGUser cgU = CGUserModelConverter.ConvertFromClientUserToServiceUser(user);
proxy.DeleteHand(cgU);
return(proxy.DeleteCGUser(cgU));
}
}
public GameTableModel CreateGameTable(CGUserModel userModel, string tableName)
{
using (GameTableManagementServiceClient proxy = new GameTableManagementServiceClient()) {
GameTableModel tableModel = null;
CGUser user = GameTableModelConverter.ConvertFromClientUserToServiceUser(userModel);
tableModel = GameTableModelConverter.ConvertFromServiceGameTableToClientGameTable(proxy.CreateGameTable(user, tableName));
return(tableModel);
}
}
public static List <CGUser> ConvertFromListOfCGUserModelToListOfCGUser(List <CGUserModel> cGUserModels)
{
List <CGUser> cGUsers = new List <CGUser>();
foreach (CGUserModel cGUserModel in cGUserModels)
{
CGUser cGUser = convertFromCGUserModelToCGUser(cGUserModel);
cGUsers.Add(cGUser);
}
return(cGUsers);
}
public void DeleteHand(CGUser user)
{
if (user == null)
{
throw new ArgumentNullException();
}
else
{
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
cGUserDB.DeleteHand(userModel);
}
}
/* This method is called when a user want to join a GameTable.
* It checks wether or notthe table is already full and if it is the user cannot join the table.
* if a user is successfull in joining a table, a seat is subtracted from the seat count,
* such that the it can keep track of how many users have joined the table
*/
public GameTable JoinGameTable(CGUser user, GameTable chosenTable)
{
if (user == null || chosenTable == null)
{
throw new ArgumentNullException();
}
else
{
GameTable databaseTable = null;
GameTableModel modelTable = null;
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
//Checking if the user is already sitting at the table and returning it without modifying if so.
for (int i = 0; i < chosenTable.Users.Count; i++)
{
if (userModel.UserName == chosenTable.Users[i].UserName)
{
return(chosenTable);
}
}
TransactionOptions transOptions = new TransactionOptions();
transOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, transOptions)) {
//Checking if the user is sitting at another table.
if (userModel.TableID != 0 && userModel.TableID != chosenTable.Id)
{
modelTable = gameTableDB.GetById(userModel.TableID);
}
//Getting the table from the database for later comparison.
databaseTable = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTableDB.GetById(chosenTable.Id));
//Optimistically handling concurrency by checking if the seats available at the chosen table
//are the same as the seats available in the database, if not we throw an exception.
if (chosenTable.seats == databaseTable.seats && databaseTable.seats > 0)
{
userManagement.UpdateUserTableId(user, databaseTable.Id);
databaseTable.Users.Add(user);
UpdateGameTableSeats(databaseTable, 1);
//If the user was sitting at another table we free up the seat.
if (modelTable != null)
{
gameTableDB.UpdateGameTableSeats(modelTable, -1);
}
}
else
{
throw new Exception("Table busy");
}
Thread.Sleep(2000);
scope.Complete();
}
return(databaseTable);
}
}
public void UpdateUserTableId(CGUser user, int tableId)
{
if (user == null || tableId == 0)
{
throw new ArgumentNullException();
}
else
{
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
cGUserDB.UpdateUserTableId(userModel, tableId);
}
}
public void UpdateUser(CGUser user)
{
if (user == null)
{
throw new ArgumentNullException();
}
else
{
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
cGUserDB.Update(userModel);
}
}
public void SaveHand(List <Card> cards, CGUser user)
{
if (cards == null || user == null)
{
throw new ArgumentNullException();
}
else
{
List <CardModel> cardModels = CardConverter.ConvertFromListOfCardToListOfCardModel(cards);
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
cGUserDB.InsertHand(cardModels, userModel);
}
}
public static GameTableServiceReference.CGUser ConvertFromClientUserToServiceUser(CGUserModel modelUser)
{
CGUser serviceUser = new CGUser()
{
Id = modelUser.Id,
UserName = modelUser.UserName,
Email = modelUser.Email,
//userType = (Models.CGUserModel.UserType)serviceUser.userType,
//userStatus = (Models.CGUserModel.UserStatus)serviceUser.userStatus,
//Health = serviceUser.Health,
};
return(serviceUser);
}
public void CreateGameTableTest()
{
// arrange
gameTableManagement = new GameTableManagement();
IGameTableDBIF tableDB = new GameTableDB();
var user1 = new CGUser();
//Act
var table = gameTableManagement.CreateGameTable(user1, "GameTable");
var tableModel = tableDB.GetGameTableByTableName("GameTable");
//Assert
Assert.AreEqual(tableModel.TableName, "GameTable");
//Cleanup
tableDB.Delete(tableModel);
}
public void DeleteGameTableTest()
{
// arrange
gameTableManagement = new GameTableManagement();
IGameTableDBIF tableDB = new GameTableDB();
ICGUserDBIF userDB = new CGUserDB();
CGUser user = CGUserConverter.convertFromCGUserModelToCGUser(userDB.GetById("Test"));
gameTableManagement.CreateGameTable(user, "TestTable");
GameTable table = gameTableManagement.GetGameTableByTableName("TestTable");
//Act
gameTableManagement.DeleteGameTable(table.Id);
//Assert
Assert.IsNull(tableDB.GetById(table.Id));
}
public static CGUser convertFromCGUserModelToCGUser(CGUserModel cGUserModel)
{
ICardDBIF cardDB = new CardDB();
List <CardModel> userCards = cardDB.GetCardsByUserId(cGUserModel.Id);
CGUser cGUser = new CGUser()
{
Id = cGUserModel.Id,
UserName = cGUserModel.UserName,
Email = cGUserModel.Email,
userType = (CGUser.UserType)cGUserModel.userType,
userStatus = (CGUser.UserStatus)cGUserModel.userStatus,
Health = cGUserModel.Health,
cards = CardConverter.ConvertFromListOfCardModelToListOfCard(userCards)
};
return(cGUser);
}
public bool DeleteCGUser(CGUser user)
{
if (user == null)
{
throw new ArgumentNullException();
}
else
{
bool res = false;
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
if (userModel != null)
{
cGUserDB.UpdateTableSeats(userModel, -1);
cGUserDB.Delete(userModel);
res = true;
}
return(res);
}
}
public GameTable CreateGameTable(CGUser user, string tableName)
{
if (user == null || tableName == null)
{
throw new ArgumentNullException();
}
else
{
GameTableModel tableModel = new GameTableModel()
{
TableName = tableName,
DeckId = 2,
seats = 4
};
gameTableDB.Insert(tableModel);
GameTable table = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTableDB.GetGameTableByTableName(tableName));
return(JoinGameTable(user, table));
}
}
public static CGUserModel ConvertFromCGUserToCGUserModel(CGUser cGUser)
{
ICGUserDBIF userDB = new CGUserDB();
CGUserModel cGUserModel = new CGUserModel()
{
Id = cGUser.Id,
UserName = cGUser.UserName,
Email = cGUser.Email,
userType = (CGUserModel.UserType)cGUser.userType,
userStatus = (CGUserModel.UserStatus)cGUser.userStatus,
Health = cGUser.Health
};
if (userDB.GetUserTableId(cGUser.Id) != 0)
{
cGUserModel.TableID = userDB.GetUserTableId(cGUser.Id);
}
return(cGUserModel);
}
public void JoinGameTableTest()
{
//Assert
gameTableManagement = new GameTableManagement();
ICGUserDBIF userDB = new CGUserDB();
List <GameTable> tables = (List <GameTable>)gameTableManagement.GetAll();
GameTable table = null;
if (tables != null)
{
table = tables[0];
}
CGUser user = CGUserConverter.convertFromCGUserModelToCGUser(userDB.GetById("Test"));
//Act
GameTable table2 = gameTableManagement.JoinGameTable(user, table);
//Assert
Assert.IsTrue(table.Users.Count < table2.Users.Count);
//Cleanup
gameTableManagement.UpdateGameTableSeats(table2, -1);
userDB.UpdateUserTableId(CGUserConverter.ConvertFromCGUserToCGUserModel(user), 0);
}
