public Round StartRoundOrGetExisting(int userId)
{
GameEntity gameEntity = StartNewGameOrGetExisting(userId);
RoundEntity roundEntity = _roundRepository.GetCurrentOpenRound(gameEntity.Id);
if (null != roundEntity)
{
// Unfinished round
return(RoundEntityFactory.Create(roundEntity, ROUNDS_PER_GAME, RoundsPlayedInGame(gameEntity.Id)));
}
roundEntity = RoundEntityFactory.Create(gameEntity.Id);
// Determine the correct one
var randomImages = _imageRepository.GetRandomImages(IMAGES_PER_ROUND, _userRepository.Get(userId).FullName);
int indexOfCorrectImageInList = (new Random()).Next(IMAGES_PER_ROUND);
var correctImage = randomImages.ElementAt(indexOfCorrectImageInList);
Round round = RoundFactory.Create(new List <Image>(), RoundsPlayedInGame(gameEntity.Id), ROUNDS_PER_GAME, correctImage.Name);
roundEntity.CorrectImageId = correctImage.Id;
_roundRepository.Create(roundEntity);
foreach (ImageEntity imageEntity in randomImages)
{
ImageInRoundEntity imageInRoundEntity = ImageInRoundEntityFactory.Create(imageEntity.Id, roundEntity.Id);
_imageInRoundRepository.Create(imageInRoundEntity);
round.Images.Add(ImageFactory.Create(imageEntity.Url, imageEntity.Id));
}
return(round);
}
public void GenerateRound()
{
var roundNumbers = new List <int>();
var rnd = new Random();
var i = 0;
while (i < 7)
{
var check = rnd.Next(1, 37);
if (!roundNumbers.Contains(check))
{
roundNumbers.Add(check);
i++;
}
}
var numbers = string.Join(";", roundNumbers.OrderBy(x => x));
var model = _roundRepository.GetAll().FirstOrDefault(r => string.IsNullOrEmpty(r.WinningComination));
model.WinningComination = numbers;
model.DateResults = DateTime.Now;
model.PayIn = CalculateProfit(model.Id);
model.PayOut = CalculateLoss(model.Id);
_roundRepository.Update(model);
_roundRepository.Create(new Round
{
CreatedRound = DateTime.Now
});
}
public async Task <ResponseGameViewModel> CreateNewRound(int gameId)
{
var deckFromCache = _deckProvider.Get();
var game = await _gameRepository.Get(gameId);
var round = new Round {
GameId = gameId
};
await _roundRepository.Create(round);
var userGames = (await _userGamesRepository.Get(game));
var users = (await _userRepository.Get(userGames)).Where(x => x.UserRole != UserRole.Dealer);
var userRounds = new List <UserRound>();
CheckDeck(deckFromCache);
for (int i = 0; i < users.Count(); i++)
{
userRounds.Add(new UserRound {
RoundId = round.Id, UserId = users.ElementAt(i).Id
});
}
await _userRoundRepository.CreateRange(userRounds);
return(await GameResponse(gameId));
}
public ActionResult Update(Round round)
{
ApiResult <Round> apiResult;
if (ModelState.IsValid)
{
if (round.Id > 0)
{
apiResult = TryExecute(() =>
{
_roundRepository.Update(round);
_unitOfWork.Commit();
return(round);
}, "Interview Round updated sucessfully");
}
else
{
apiResult = TryExecute(() =>
{
_roundRepository.Create(round);
_unitOfWork.Commit();
return(round);
}, "Interview Round created sucessfully");
}
}
else
{
apiResult = ApiResultFromModelErrors <Round>();
}
return(Json(apiResult, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(Round round)
{
if (ModelState.IsValid)
{
_roundRepository.Create(round);
_unitOfWork.Commit();
return(RedirectToAction("Index"));
}
return(View(round));
}
public void StartFirstRound(int gameId, IEnumerable <int> playersId)
{
int number = _roundRepository.GetCountRoundsByGame(gameId);
Round round = new Round
{
GameId = gameId,
NumberRound = number + 1,
IsCompleted = false
};
round.Id = _roundRepository.Create(round);
foreach (int id in playersId)
{
RoundPlayer roundPlayer = new RoundPlayer
{
RoundId = round.Id,
PlayerId = id
};
_roundPlayerRepository.Create(roundPlayer);
}
}
public async Task <GetRoundGameView> GetRound(int gameId)
{
Game game = await _gameRepository.Get(gameId);
if (game == null)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("GameId: {0}", gameId));
stringBuilder.AppendLine(string.Format("Message: {0}", SolutionConstants.BUSINESS_LOGIC_GET_ITEM_EXCEPTION_MESSAGE));
string message = stringBuilder.ToString();
throw new BusinessLogicGetItemException(message);
}
var responseView = new GetRoundGameView();
if (!game.IsFinished)
{
Round round = await _roundRepository.GetLastRound(gameId);
var newRound = new Round();
newRound.GameId = gameId;
newRound.NumberOfRound = round != null ? (round.NumberOfRound + GameConstants.NEXT_ROUND) : GameConstants.FIRST_ROUND;
await SetFinishedGameIfEndedRounds(newRound.NumberOfRound, game);
await _roundRepository.Create(newRound);
responseView.RoundId = newRound.Id;
responseView.NumberOfRound = newRound.NumberOfRound;
}
return(responseView);
}
public Round Create(Round round)
{
var validatedRound = _roundVali.ValidateRound(round);
return(_roundRepo.Create(validatedRound));
}
