public async Task CommitGuess(string guessingTeam, GuessRequestBody requestBody, GuessResponseBody responseBody)
{
long pointsScored = 0;
foreach (var guess in responseBody.Guesses)
{
pointsScored += guess.Score;
}
var guessId = Guid.NewGuid();
await _context.Guesses.AddAsync(new Guess
{
GameId = _gameContext.GameId,
RoundId = _gameContext.RoundId,
GuessId = guessId,
TeamId = guessingTeam,
GuessRequest = requestBody,
GuessResponse = responseBody,
TimeStamp = DateTime.UtcNow
});
await _context.Scores.AddAsync(new Score
{
GameId = _gameContext.GameId,
RoundId = _gameContext.RoundId,
PointsScored = pointsScored,
GuessId = guessId,
TeamId = guessingTeam,
TimeStamp = DateTime.UtcNow
});
await _context.SaveChangesAsync();
}
private GuessResponseBody Validate(GuessRequestBody body, string guessingTeam)
{
var guesses = body.Guesses;
if (body.Guesses != null && body.Guesses.Count() > MAX_GUESSES)
{
throw new GuessLimitExceededException();
}
var guessResponseBody = new GuessResponseBody {
Guesses = new List <SingleGuessResponseObject>()
};
foreach (var guess in guesses)
{
var targetTeam = guess.Team;
var secretGuess = guess.Guess;
var guessResponseObject = new SingleGuessResponseObject();
if (string.IsNullOrWhiteSpace(targetTeam) || !IsTeamRegexValid(targetTeam))
{
guessResponseObject.ErrMessage = "Invalid team";
}
else if (string.IsNullOrWhiteSpace(secretGuess) || !IsGuessRegexValid(secretGuess))
{
guessResponseObject.ErrMessage = "Invalid guess";
}
else if (targetTeam == guessingTeam)
{
guessResponseObject.ErrMessage = "Can't guess for yourself";
}
if (string.IsNullOrEmpty(guessResponseObject.ErrMessage))
{
guessResponseObject.IsValid = true;
}
guessResponseObject.TargetTeam = targetTeam;
guessResponseObject.Guess = secretGuess;
guessResponseBody.Guesses.Add(guessResponseObject);
}
return(guessResponseBody);
}
private GuessRequestBody PreProcess(GuessRequestBody requestBody)
{
if (requestBody == null || requestBody.Guesses == null)
{
throw new InvalidDataProvidedException($"Found Invalid Data in GuessRequestBody {requestContext.RequestId}");
}
var newModel = new GuessRequestBody();
newModel.Guesses = new List <SingleGuessRequestObject>();
foreach (var guess in requestBody.Guesses)
{
newModel.Guesses.Add(new SingleGuessRequestObject
{
Team = guess.Team.ToLowerInvariant(),
Guess = guess.Guess.ToLowerInvariant()
});
}
return(newModel);
}
public async Task <JsonResult> Post([FromBody] GuessRequestBody requestBody)
{
JsonResult response;
try
{
GuessResponse guessResponse = new GuessResponse()
{
RequestId = requestContext.RequestId
};
if (!gameContext.CurrentPhase.Equals(PhaseType.Running))
{
throw new GameNotInRunningPhaseException();
}
if (gameContext.Participants.Where(p => p.TeamId == User.Identity.Name && p.IsAlive != null && p.IsAlive == true).FirstOrDefault() == null)
{
throw new TeamNotJoinedException();
}
var guesses = requestBody.Guesses;
var body = PreProcess(requestBody);
var validatedBody = Validate(body, User.Identity.Name);
await Evaluate(validatedBody);
await CommitGuess(validatedBody, requestBody);
guessResponse.Data = new GuessResponseData {
Guesses = validatedBody.Guesses,
GameId = gameContext.GameId,
RoundId = gameContext.RoundId,
RoundNumber = gameContext.RoundNumber,
Status = gameContext.CurrentPhase.ToString()
};
response = new JsonResult(guessResponse)
{
StatusCode = 200
};
}
catch (GuessLimitExceededException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Guess Limit Exceeded",
Description = $"At max {MAX_GUESSES} guesses are allowd at a time"
}
})
{
StatusCode = 400
};
}
catch (GameNotInRunningPhaseException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Game is not in running phase",
Description = "/guess api requests are only accepted in Running phase"
}
})
{
StatusCode = 400
};
}
catch (TeamNotJoinedException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Team not alive or joined",
Description = "Either you have not joined this round or your team is dead."
}
})
{
StatusCode = 400
};
}
catch (InvalidDataProvidedException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Invalid Request Body",
Description = "Please provide a proper body for the api"
}
})
{
StatusCode = 400
};
}
catch (Exception)
{
logger.LogError($"Error Occurred while fetching current gamestatus");
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Internal Server Error",
Description = "Server Failed to fetch Current Gamestatus"
}
})
{
StatusCode = 500
};
}
return(response);
}
private async Task CommitGuess(GuessResponseBody validatedBody, GuessRequestBody requestBody)
{
await gameApiService.CommitGuess(User.Identity.Name, requestBody, validatedBody);
}
