Esempio n. 1
0
        public async Task <IActionResult> Add(BasketGameDto basketGameDto)
        {
            int _points = 0;

            int.TryParse(basketGameDto.Points, out _points);


            if (_points < 0)
            {
                return(BadRequest("A pontuação deve ser igual ou maior que (0)zero"));
            }

            try
            {
                var gameToCreate = new BasketGame
                {
                    GameDate = basketGameDto.GameDate,
                    Points   = _points
                };

                var createdGame = await _repo.Add(gameToCreate);

                await _repo.AddRecord(createdGame);

                return(StatusCode(201));
            }
            catch (Exception ex)
            {
                return(BadRequest("Erro ao tentar registar jogo: " + ex.Message));
            }
        }
Esempio n. 2
0
        //public async Task<IActionResult> AddToBasket(int basketId, int gameId)
        public async Task <IActionResult> AddToBasket(int?id)
        {
            //int gameId = 1;
            var basket = await _context.Baskets.Include(x => x.BasketGames).FirstOrDefaultAsync(x => x.Id == 3);

            if (basket == null)
            {
                basket = new Basket();
                await _context.Baskets.AddAsync(basket);

                await _context.SaveChangesAsync();
            }
            var game = await _context.Games.FirstOrDefaultAsync(x => x.Id == id);

            var basketGame = new BasketGame();

            if (game != null && basket.BasketGames.Count(x => x.GameId == id) == 0)
            {
                basketGame.BasketId = basket.Id;
                basketGame.GameId   = game.Id;
                await _context.BasketsGames.AddAsync(basketGame);

                await _context.SaveChangesAsync();
            }
            return(RedirectToAction("Index", "Games"));
        }
Esempio n. 3
0
        private async Task <BasketGame> CheckRecord(BasketGame newGame)
        {
            var gameList = await _context.BasketGame.ToListAsync();

            if (gameList.Count > 1)
            {
                var recordList = await _context.RecordGame.ToListAsync();

                if (recordList.Count >= 1)
                {
                    var lastRecord = recordList.OrderByDescending(o => o.Id).FirstOrDefault();

                    if (newGame.Points > lastRecord.Points)
                    {
                        return(newGame);
                    }
                }
                else
                {
                    gameList.OrderBy(o => o.Id);
                    var oldGame = gameList[gameList.Count - 2];
                    if (newGame.Points > oldGame.Points)
                    {
                        return(newGame);
                    }
                }
            }

            return(null);
        }
Esempio n. 4
0
        public async Task <BasketGame> Add(BasketGame game)
        {
            await _context.AddAsync(game);

            await _context.SaveChangesAsync();

            return(game);
        }
Esempio n. 5
0
        public async Task <RecordGame> AddRecord(BasketGame newGame)
        {
            if (CheckRecord(newGame).Result != null)
            {
                var record = new RecordGame
                {
                    Points = newGame.Points
                };

                await _context.AddAsync(record);

                await _context.SaveChangesAsync();

                return(record);
            }

            return(null);
        }