public async Task <IActionResult> UpdateList([FromBody] UpdateRequest reqBody)
{
CUDMessage message = new CUDMessage();
if (!string.IsNullOrEmpty(reqBody.condition.ToString()) && !string.IsNullOrEmpty(reqBody.token.ToString()))
{
message = await playerService.UpdatePlayers(reqBody.condition, reqBody.token);
if (message.OK)
{
message.Message = "Successfuly updated the selected player(s)";
return(Ok(message));
}
else
{
Response.StatusCode = 500;
message.Message = "Failed to update the selected player(s)!";
return(new JsonResult(message));
}
}
message.Message = "Invalid parameters provided";
Response.StatusCode = 400;
return(new JsonResult(message));
}
public async Task <CUDMessage> AddGame(string playerName, List <string> gameNames)
{
int gameInputNum = gameNames.Count;
// stop here if list is empty
if (gameInputNum <= 0)
{
return(new CUDMessage()
{
OK = false,
NumAffected = 0,
Message = $"No games are added to player {playerName} since the input list is empty.",
});
}
// check if player exists
Player player = await playerService.Get(playerName);
if (player is null)
{
return(new CUDMessage()
{
OK = false,
NumAffected = 0,
Message = $"Player {playerName} does not exist.",
});
}
// remove duplicate game entries
gameNames = gameNames.Distinct().ToList();
// remove games that are already owned
RemovePlayerAddGameConflict(player, gameNames);
// stop here if no valid games
if (gameNames.Count <= 0)
{
return(new CUDMessage()
{
OK = false,
NumAffected = 0,
Message = $"No games can be added to player {player.DBName} because non of these inputs are valid. Try add them one by one if you are not sure why.",
});
}
// begin adding these games to player
CUDMessage message = await playerService.AddGame(player, gameNames);
if (!message.OK)
{
Console.WriteLine(message.Message);
message.Message = $"Failed to add {gameNames.Count} games to player {player.DBName}. See logs for details.";
}
else
{
message.Message = $"Adding games to player {player.DBName}: {gameNames.Count} success, {gameInputNum - gameNames.Count } failure.";
}
return(message);
}
public async Task <IActionResult> Delete(string dbname)
{
CUDMessage message = await playerService.DeletePlayer(dbname);
if (message.OK)
{
message.Message = "Successfuly deleted player: " + dbname;
return(Ok(message));
}
else
{
message.Message = "Failed to add the player: " + dbname + "!";
Response.StatusCode = 500;
return(new JsonResult(message));
}
}
public async Task <IActionResult> Add([FromBody] Player newPlayer)
{
CUDMessage message = await playerService.AddPlayer(newPlayer);
if (message.OK)
{
message.Message = "Successfuly added the new player: " + newPlayer.DBName;
return(Ok(message));
}
else
{
message.Message = "Failed to add the player: " + newPlayer.DBName + "!";
Response.StatusCode = 500;
return(new JsonResult(message));
}
}
public IActionResult Delete(string dbname)
{
CUDMessage message = factionService.DeleteFaction(dbname);
if (message.OK)
{
message.Message = $"Successfully deleted {dbname}";
return(Ok(message));
}
else
{
message.Message = $"Failed to delete {dbname}";
Response.StatusCode = 500;
return(new JsonResult(message));
}
}
public IActionResult Post([FromBody] Faction newFaction)
{
CUDMessage message = factionService.AddFaction(newFaction);
if (message.OK)
{
message.Message = $"Successfully added {newFaction.DBName}";
return(Ok(message));
}
else
{
message.Message = $"Failed to add {newFaction.DBName}";
Response.StatusCode = 500;
return(new JsonResult(message));
}
}
public async Task <CUDMessage> AddPlayer(Player newPlayer)
{
CUDMessage message = new CUDMessage()
{
OK = true,
NumAffected = 0
};
try
{
newPlayer.ID = Guid.NewGuid().ToString();
players.Add(newPlayer);
message.NumAffected = 1;
}
catch (Exception e)
{
message.OK = false;
message.Message = e.ToString();
}
return(message);
}
public async Task <CUDMessage> AddPlayer(Player newPlayer)
{
var message = new CUDMessage()
{
NumAffected = 1,
OK = true
};
try
{
await context.Players.InsertOneAsync(newPlayer);
}
catch (Exception e)
{
message.OK = false;
message.NumAffected = 0;
message.Message = e.ToString();
}
return(message);
}
public async Task <CUDMessage> AddSingle(T newItem)
{
var message = new CUDMessage()
{
NumAffected = 1,
OK = true
};
try
{
await collection.InsertOneAsync(newItem);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
message.OK = false;
message.NumAffected = 0;
}
return(message);
}
public async Task <CUDMessage> AddGame(string playerName, string gameName)
{
// check if player exists
Player player = await playerService.Get(playerName);
if (player is null)
{
return(new CUDMessage()
{
OK = false,
NumAffected = 0,
Message = $"Player {playerName} does not exist.",
});
}
// check if player has already owned the game
if (player.Games.Exists(ele => ele == gameName))
{
return(new CUDMessage()
{
OK = false,
NumAffected = 0,
Message = $"Player {player.DBName} already owns the Game {gameName}.",
});
}
// begin adding the game to player
CUDMessage message = await playerService.AddGame(playerName, gameName);
if (!message.OK)
{
Console.WriteLine(message.Message);
message.Message = $"Failed to add game {gameName} to player {playerName}. See logs for details.";
}
else
{
message.Message = $"Successfully added game {gameName} to player {playerName}.";
}
return(message);
}
public async Task <CUDMessage> DeletePlayer(string dbname)
{
CUDMessage message = new CUDMessage()
{
OK = true,
NumAffected = 0
};
Player player = players.FirstOrDefault((player) => { return(player.DBName == dbname); });
if (player != null)
{
players.Remove(player);
message.NumAffected = 1;
}
else
{
message.NumAffected = 0;
}
return(message);
}
public async void TestCRUDSingle(Player newPlayer, JsonElement updateToken)
{
// Add single
CUDMessage addMessage = await playerService.AddSingle(newPlayer);
Assert.True(addMessage.OK);
IPlayer playerInDB = await playerService.GetSingle(newPlayer.DBName);
Assert.NotNull(playerInDB);
// update single
CUDMessage updateMessage = await playerService.UpdateSingle(newPlayer.DBName, updateToken);
playerInDB = await playerService.GetSingle(newPlayer.DBName);
Assert.Equal("game-tesV", playerInDB.Games[0]);
// delete single
CUDMessage deleteMessage = await playerService.DeleteSingle(newPlayer.DBName);
Assert.True(deleteMessage.OK);
playerInDB = await playerService.GetSingle(newPlayer.DBName);
Assert.Null(playerInDB);
}
public async void TestAddGame(Player newPlayer, string aGame, List <string> moreGames)
{
// Add a player
CUDMessage addMessage = await playerService.Add(newPlayer);
Assert.True(addMessage.OK);
// Add a game
CUDMessage addGameMessage = await playerService.AddGame(newPlayer.DBName, aGame);
Assert.True(addGameMessage.OK);
// Add more games
addGameMessage = await playerService.AddGame(newPlayer.DBName, moreGames);
Assert.True(addGameMessage.OK);
// Game item check
Player playerInDB = await playerService.Get(newPlayer.DBName);
// Last game item should be the same as the last added game item in "moreGames"
Assert.True(playerInDB.Games[moreGames.Count] == moreGames[moreGames.Count - 1]);
}
public IActionResult Patch([FromBody] UpdateRequest reqBody)
{
var message = new CUDMessage();
if (!string.IsNullOrEmpty(reqBody.condition.ToString()) && reqBody.token != null)
{
message = factionService.UpdateFactions(reqBody.condition, reqBody.token);
if (message.OK)
{
message.Message = "Successfuly updated the selected faction(s)";
return(Ok(message));
}
else
{
Response.StatusCode = 500;
message.Message = "Failed to update the selected faction(s)!";
return(new JsonResult(message));
}
}
message.Message = "Invalid parameters provided";
Response.StatusCode = 400;
return(new JsonResult(message));
}
public async void TestCRUDList(List <Player> newPlayers, JsonElement updateCondition, JsonElement updateToken)
{
// Add many
CUDMessage addMessage = await playerService.AddList(newPlayers);
Assert.True(addMessage.OK);
List <Player> playersInDB = await playerService.GetList(JsonDocument.Parse("{}").RootElement);
Assert.True(playersInDB.Count == 3);
// update many
CUDMessage updateMessage = await playerService.UpdateList(updateCondition, updateToken);
Assert.Equal(2, updateMessage.NumAffected);
playersInDB = await playerService.GetList(JsonDocument.Parse("{}").RootElement);
Assert.Equal(2, playersInDB[2].CDKeys.Count);
// delete many
CUDMessage deleteMessage = await playerService.DeleteList(updateCondition);
Assert.True(deleteMessage.NumAffected == 2);
playersInDB = await playerService.GetList(JsonDocument.Parse("{}").RootElement);
Assert.True(playersInDB.Count == 1);
}
public async void TestActivate(
Player player,
List <Game> games,
Dictionary <string, List <string> > cdkeys
)
{
// prepare player + games
CUDMessage addPlayerMessage = await playerService.Add(player);
Assert.True(addPlayerMessage.OK);
CUDMessage addGameMessage = await gameService.Add(games);
Assert.True(addGameMessage.OK);
// create CDK instances for the games according to the map (at this time: player is null)
foreach (var pair in cdkeys)
{
foreach (var cdkValue in pair.Value)
{
var cdkey = new CDKey()
{
Game = pair.Key,
Value = cdkValue,
IsActivated = false,
};
CUDMessage addCDKMessage = await cdkeyService.Add(cdkey);
Assert.True(addCDKMessage.OK);
}
}
// Activate one cdk. Should be able to add, and player then has the game.
// -> (player not null + appear in "games" field in player instance) We should get the cdk instance.
InstanceCUDMessage <CDKey> activateMessage = await cdkeyService.Activate(player.DBName, cdkeys[games[0].DBName][0]);
CDKey singleCDK = activateMessage.Instance;
Assert.True(singleCDK.Player == player.DBName);
Player playerInDB = await playerService.Get(player.DBName);
Assert.NotNull(playerInDB.Games.Find(ele => ele == games[0].DBName));
// Activate multiple cdks. Should be able to add, and player then has the list of games. We should get a list of cdk instance.
var cdkValues = new List <string> {
cdkeys[games[1].DBName][0],
cdkeys[games[2].DBName][0],
};
activateMessage = await cdkeyService.Activate(player.DBName, cdkValues);
List <CDKey> multipleCDKs = activateMessage.Instances;
Assert.True(multipleCDKs[1].Player == player.DBName);
playerInDB = await playerService.Get(player.DBName);
Assert.True(playerInDB.Games.Count == 1 + 2);
// Activate an invalid CDKey. Message should not be okay.
activateMessage = await cdkeyService.Activate(player.DBName, "2GDH1-5BDK2-BILLY-3CDK4"); // 风暴英雄CDK
Console.WriteLine(activateMessage.Message);
Assert.False(activateMessage.OK);
// Activate duplicate keys. Message should not be okay because:
// 1. key already activated
activateMessage = await cdkeyService.Activate(player.DBName, cdkeys[games[0].DBName][0]);
Console.WriteLine(activateMessage.Message);
Assert.False(activateMessage.OK);
// 2. player already owns the game, activation should fail.
activateMessage = await cdkeyService.Activate(player.DBName, cdkeys[games[1].DBName][1]);
Console.WriteLine(activateMessage.Message);
Assert.False(activateMessage.OK);
CDKey cdkeyInDB = await cdkeyService.GetByValue(cdkeys[games[1].DBName][1]);
//(await cdkeyService.Get(JsonDocument.Parse("{" + "\"value\": " + $"\"{cdkeys[games[1].DBName][1]}\"" + "}").RootElement))[0];
Assert.False(cdkeyInDB.IsActivated);
// Activate multiple keys contains duplications.
// we should get a list of successfully added cdk instances,
// and the games will only be added if player does not own those games
cdkValues = new List <string> {
cdkeys[games[2].DBName][0], // (key already activated)
cdkeys[games[2].DBName][1], // duplicate game
cdkeys[games[3].DBName][0], // good
};
activateMessage = await cdkeyService.Activate(player.DBName, cdkValues);
multipleCDKs = activateMessage.Instances;
Assert.True(multipleCDKs.Count == 1);
// check game[2] should not be activated
// "player" field of unsuccessfully added cdkeys should remain null
cdkeyInDB = await cdkeyService.GetByValue(cdkeys[games[2].DBName][1]);
// (await cdkeyService.Get(JsonDocument.Parse("{" + "\"value\": " + $"\"{cdkeys[games[2].DBName][1]}\"" + "}").RootElement))[0];
Assert.False(cdkeyInDB.IsActivated);
Assert.Null(cdkeyInDB.Player);
// player should own game[3]
playerInDB = await playerService.Get(player.DBName);
Assert.NotNull(playerInDB.Games.Find(ele => ele == games[3].DBName));
}
