protected override Response DeleteHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest($"No authorization header found"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
if (request.RouteTokens.Length != 2)
{
return(ResponseManager.BadRequest("invalid request"));
}
TradeDealsRepository dealer = new TradeDealsRepository();
if (!dealer.DealExists(request.RouteTokens[1]))
{
return(ResponseManager.NotFound($"Deal {request.RouteTokens[1]} not found"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
if (!dealer.HasDeal(username, request.RouteTokens[1]))
{
return(ResponseManager.BadRequest($"Deal {request.RouteTokens[1]} is not yours!"));
}
dealer.RemoveDeal(request.RouteTokens[1]);
return(ResponseManager.OK($"Deal {request.RouteTokens[1]} successfully deleted"));
}
// POST to users => sign up
protected override Response PostHandler(Request request)
{
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("No payload"));
}
UserData user = JsonSerializer.Deserialize <UserData>(request.Payload);
if (user.Username.IsNullOrWhiteSpace() || user.Password.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Username or Password Empty"));
}
UsersRepository users = new UsersRepository();
if (users.UserExists(user.Username))
{
return(ResponseManager.BadRequest($"Username {user.Username} allready exists"));
}
if (!users.RegisterUser(user))
{
return(ResponseManager.InternalServerError());
}
return(ResponseManager.Created($"Account for {user.Username} created successfully"));
}
protected override Response PostHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest($"No authorization header found"));
}
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest($"No payload found"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
switch (request.RouteTokens.Length)
{
case 1: return(CreateTradeDeal(request));
case 2: return(HandleTradeDeal(request, request.RouteTokens[1]));
}
return(ResponseManager.InternalServerError());
}
// POST to sessions => login => generate token and save it in the session
protected override Response PostHandler(Request request)
{
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("no payload"));
}
UserData user = JsonSerializer.Deserialize <UserData>(request.Payload);
if (user.Username.IsNullOrWhiteSpace() || user.Password.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("empty username or password"));
}
bool authorized = new UsersRepository().Verify(user);
if (authorized)
{
if (Session.HasSession(user.Username))
{
return(ResponseManager.OK($"{user.Username} allready has an active session"));
}
string token = GenerateToken(user.Username);
Session.CreateSession(user.Username, token);
return(ResponseManager.OK(token));
}
return(ResponseManager.NotFound("Invalid Credentials"));
}
// PUT to /deck => configure deck
protected override Response PutHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("No Payload"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized("check your username and password"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
var cards = JsonSerializer.Deserialize <List <string> >(request.Payload);
// easy solution - accept only four cards. what if user wants to change only one card?
// consider making this dynamic
if (cards.Count != Config.DECKSIZE)
{
return(ResponseManager.BadRequest($"Deck size must be {Config.DECKSIZE}"));
}
var decks = new DecksRepository();
decks.UpdateDeck(username, cards.ToArray()); // TEST THIS
return(ResponseManager.OK("deck updated successfully"));
}
// GET to users => read user's data
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
if (request.RouteTokens.Length != 2)
{
return(ResponseManager.BadRequest("Invalid format"));
}
string requestedUsername = request.RouteTokens[1];
if (requestedUsername != Session.GetUsername(ExtractAuthorizationToken(request.Authorization)))
{
return(ResponseManager.Unauthorized($"you are not {requestedUsername}"));
}
UsersRepository usersRepo = new UsersRepository();
if (!usersRepo.UserExists(requestedUsername))
{
return(ResponseManager.NotFound($"Username {requestedUsername} does not exist"));
}
UserData user = usersRepo.GetUser(requestedUsername);
return(ResponseManager.OK(JsonSerializer.Serialize <UserData>(user)));
}
// GET to /deck => show current deck
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized("check your username and password"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
var deckRepo = new DecksRepository();
if (deckRepo.Empty(username))
{
return(ResponseManager.OK($"the deck for user {username} is empty"));
}
CardData[] cards = deckRepo.GetDeck(username);
string deck = JsonSerializer.Serialize <CardData[]>(cards);
return(ResponseManager.OK(deck));
}
public Response HandleRequest(Request request)
{
try
{
switch (request.Method.ToUpper())
{
case "GET": return(GetHandler(request));
case "PUT": return(PutHandler(request));
case "POST": return(PostHandler(request));
case "DELETE": return(DeleteHandler(request));
default: return(ResponseManager.MethodNotAllowed($"The method {request.Method.ToUpper()} is not supported"));
}
}
catch (InvalidDataException ex)
{
return(ResponseManager.BadRequest(ex.Message));
}
catch (JsonException ex)
{
return(ResponseManager.BadRequest("Invalid json: " + ex.Message));
}
catch (Exception ex)
{
ex.Log();
}
return(ResponseManager.InternalServerError());
}
private Response HandleTradeDeal(Request request, string dealId)
{
var dealer = new TradeDealsRepository();
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
if (!dealer.DealExists(dealId))
{
return(ResponseManager.NotFound($"deal {dealId} does not exist"));
}
var deal = dealer.GetDeal(dealId);
var users = new UsersRepository();
if (deal.OwnerId == users.GetUserID(username))
{
return(ResponseManager.BadRequest("you can't trade with yourself"));
}
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("no payload"));
}
string offeredCardId = request.Payload.Replace('\"', ' ').Trim();
var cards = new CardsRepository();
if (!cards.CardExists(offeredCardId))
{
return(ResponseManager.BadRequest($"the offered card {offeredCardId} does not exist"));
}
if (!cards.InStack(username, offeredCardId))
{
return(ResponseManager.BadRequest($"user {username} is the not the owner of offered card {offeredCardId}"));
}
var offeredCard = cards.GetCard(offeredCardId);
if (new DecksRepository().HasCardInDeck(username, offeredCardId))
{
return(ResponseManager.BadRequest($"card {deal.CardId} is in the deck for {username}. You can't trade cards in the deck"));
}
if (OfferMeatsDealRequirements(offeredCard, deal))
{
cards.TransferOwnership(deal.OwnerId, offeredCardId);
cards.TransferOwnership(username, deal.CardId);
dealer.RemoveDeal(deal.Id);
return(ResponseManager.Created($"trade deal successfully closed."));
}
return(ResponseManager.BadRequest($"Deal requirements not met!"));
}
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest($"No authorization header found"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
TradeDeal[] deals = new TradeDealsRepository().GetDeals();
return(ResponseManager.OK(JsonSerializer.Serialize <TradeDeal[]>(deals)));
}
// post to battles => requst for a battle
protected override Response PostHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized("This action requires authorization"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
Player player = new Player(username);
var decksRepo = new DecksRepository();
if (decksRepo.Empty(username))
{
return(ResponseManager.BadRequest($"The Deck for user {username} is empty, Configure your deck before entering a battle"));
}
var deck = decksRepo.GetDeck(username);
player.MakeDeck(deck);
if (GameHandler.Instance.Enqueued(username))
{
return(ResponseManager.BadRequest($"Player {username} is allready enqueued for a battle! You can't fight yourself"));
}
var resp = ResponseManager.Created();
// https://www.c-sharpcorner.com/UploadFile/1d42da/synchronization-events-and-wait-handles-in-C-Sharp/
// https://docs.microsoft.com/en-us/dotnet/api/system.threading.manualresetevent?view=net-5.0
GameHandler.Instance.BattleEnded += (object sender, BattleEndedEventArgs args) =>
{
resp.AddPayload(args.BattleLog);
GameHandler.Instance.ResetEvent.Set(); // send the signal, all waiting threads will start running (open the door)
GameHandler.Instance.ResetEvent.Reset(); // reset the flag, new threads can wait (close the door)
};
GameHandler.Instance.EnqueuePlayer(player);
GameHandler.Instance.ResetEvent.WaitOne(); // block thread untill it gets a signal
return(resp);
}
// get /score => display all scores sorted
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
var scoreBoard = new ScoresRepository().ScoreBoard();
return(ResponseManager.OK(JsonSerializer.Serialize(scoreBoard)));
}
private Response CreateTradeDeal(Request request)
{
TradeDeal deal = JsonSerializer.Deserialize <TradeDeal>(request.Payload);
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
CardsRepository cardsRepo = new CardsRepository();
UsersRepository usersRepo = new UsersRepository();
TradeDealsRepository dealer = new TradeDealsRepository();
DecksRepository decksRepo = new DecksRepository();
if (!deal.Validate())
{
return(ResponseManager.BadRequest("invalid format for trade deal json object"));
}
if (dealer.DealExists(deal.Id))
{
return(ResponseManager.BadRequest($"trade deal with id {deal.Id} allready exists"));
}
if (username.IsNull())
{
return(ResponseManager.Unauthorized("No session found"));
}
if (!cardsRepo.CardExists(deal.CardId))
{
return(ResponseManager.NotFound($"card {deal.CardId} doesn't exist"));
}
if (!cardsRepo.InStack(username, deal.CardId))
{
return(ResponseManager.NotFound($"you don't own card {deal.CardId}"));
}
if (decksRepo.HasCardInDeck(username, deal.CardId))
{
return(ResponseManager.BadRequest($"card {deal.CardId} is in the deck for {username}. You can't trade cards in the deck"));
}
deal.OwnerId = usersRepo.GetUserID(username);
dealer.AddDeal(deal);
return(ResponseManager.Created($"trade deal {deal.Id} created"));
}
// Delete to Sessions => logout
protected override Response DeleteHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized("you don't have an active session"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
Session.EndSession(username);
return(ResponseManager.OK($"Session for {username} successfully terminated"));
}
// PUT to users => update user's info
protected override Response PutHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("No Payload"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
if (request.RouteTokens.Length != 2)
{
return(ResponseManager.BadRequest("Invalid format"));
}
string requestedUsername = request.RouteTokens[1];
if (requestedUsername != Session.GetUsername(ExtractAuthorizationToken(request.Authorization)))
{
return(ResponseManager.Unauthorized($"you are not {requestedUsername}"));
}
UsersRepository usersRepo = new UsersRepository();
if (!usersRepo.UserExists(requestedUsername))
{
return(ResponseManager.BadRequest($"Username {requestedUsername} does not exist"));
}
UserData user = JsonSerializer.Deserialize <UserData>(request.Payload);
usersRepo.UpdateUser(requestedUsername, user);
return(ResponseManager.OK($"info for user {requestedUsername} updated successfully"));
}
public Response HandleRequest(Request request)
{
IEndpointHandler endpointHandler = EndpointHandlerManager.Get(request.Endpoint);
if (endpointHandler.IsNull())
{
return(ResponseManager.BadRequest($"Endpoint {request.Endpoint} does not exist"));
}
try
{
Response resp = endpointHandler.HandleRequest(request);
return(resp);
}
catch (Exception ex)
{
ex.Log();
}
return(ResponseManager.InternalServerError());
}
// post to transactions/packages => acquire package
protected override Response PostHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
string destination = GetNthTokenFromRoute(2, request.Route);
switch (destination.ToLower())
{
case "packages": AcquirePackage(username); break;
}
return(ResponseManager.Created($"package for {username} successfully acquired"));
}
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
if (!new UsersRepository().UserExists(username))
{
return(ResponseManager.NotFound($"Username {username} does not exist"));
}
UserStats stats = new ScoresRepository().Stats(username);
return(ResponseManager.OK(JsonSerializer.Serialize(stats)));
}
// should return all cards of a user (the stack)
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("No Authorization Header found"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized("Authorization Failed!, check your username and password"));
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
CardData[] cardDataArray = new UsersRepository().GetStack(username);
if (cardDataArray.Length == 0)
{
return(ResponseManager.OK("Stack is empty"));
}
return(ResponseManager.OK(JsonSerializer.Serialize <CardData[]>(cardDataArray)));
}
// post to packages => create package
protected override Response PostHandler(Request request)
{
if (request.Payload.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("No Payload"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
if (!new UsersRepository().IsAdmin(username))
{
return(ResponseManager.Unauthorized("only admins can add new packages"));
}
CardData[] cardDataArray = JsonSerializer.Deserialize <CardData[]>(request.Payload);
new PackagesRepository().AddPackage(cardDataArray);
return(ResponseManager.Created("Package added successfully"));
}
