Beispiel #1
0
        public async Task <IServiceResult> PostGame([FromBody] SavedGameDTOs saveGameDTOs)
        {
            try
            {
                var game = _mapper.Map <SavedGameDTOs, Game>(saveGameDTOs);
                _context.Games.Add(game);
                if (!await _unitOfWork.CompleteAsync())
                {
                    throw new SaveFailedException(nameof(game));
                }
                game = await _context.Games
                       .Include(g => g.Members)
                       .ThenInclude(m => m.User)
                       .Include(g => g.FavoriteMembers)
                       .ThenInclude(m => m.User)
                       .Include(g => g.Categories)
                       .ThenInclude(c => c.Category)
                       .Include(g => g.Publisher)
                       .SingleOrDefaultAsync(g => g.Id == game.Id);

                var recallGameDTO = _mapper.Map <Game, GameDTOs>(game);
                _logger.LogInformation($"Game {recallGameDTO.Name}  created.");
                return(new ServiceResult(payload: recallGameDTO));
            }
            catch (Exception e)
            {
                _logger.LogError($"Can't post game by name: {saveGameDTOs.Name} . {e.Message}");
                return(new ServiceResult(false, message: e.Message));
            }
        }
        public void TestPostNewGameController(string name, string publisherId,
                                              string members1, string members2,
                                              string favoriteMembers1, string favoriteMembers2,
                                              float rating, string logo,
                                              string videoUrl, string content,
                                              string categories1, string categories2,
                                              float price)
        {
            Init(49914);

            SavedGameDTOs savedGameDTOs = new SavedGameDTOs()
            {
                Name        = name,
                PublisherId = publisherId.ToGuid(),
                Members     = new Collection <Guid> {
                    members1.ToGuid(), members2.ToGuid()
                },
                FavoriteMembers = new Collection <Guid> {
                    favoriteMembers1.ToGuid(), favoriteMembers2.ToGuid()
                },
                Rating     = rating,
                Logo       = logo,
                VideoUrl   = videoUrl,
                Content    = content,
                Categories = new Collection <Guid> {
                    categories1.ToGuid(), categories2.ToGuid()
                },
                Price        = price,
                PurchaseDate = DateTime.Now
            };

            using (HttpClient client = new HttpClient())
            {
                client.BaseAddress = BASE_URI;
                HttpResponseMessage result       = client.PostAsJsonAsync($"api/games", savedGameDTOs).GetAwaiter().GetResult();
                var contentResult                = result.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                Response <GameDTOs> gameResponse = JsonConvert.DeserializeObject <Response <GameDTOs> >(contentResult);
                Assert.Equal(HttpStatusCode.OK, result.StatusCode);
                Assert.True(gameResponse.IsSuccess);
            }
        }
Beispiel #3
0
        public async Task <IServiceResult> PutGame([FromRoute] Guid id, [FromBody] SavedGameDTOs savedGameDTOs)
        {
            if (id != savedGameDTOs.Id)
            {
                throw new NotFoundException(nameof(savedGameDTOs), id);
            }
            try
            {
                var game = _mapper.Map <SavedGameDTOs, Game>(savedGameDTOs);

                _context.Entry(game).State = EntityState.Modified;

                if (!await _unitOfWork.CompleteAsync())
                {
                    throw new SaveFailedException(nameof(game));
                }

                game = await _context.Games
                       .Include(g => g.Members)
                       .ThenInclude(m => m.User)
                       .Include(g => g.FavoriteMembers)
                       .ThenInclude(m => m.User)
                       .Include(g => g.Categories)
                       .ThenInclude(c => c.Category)
                       .Include(g => g.Publisher)
                       .SingleOrDefaultAsync(g => g.Id == game.Id);

                var recallGameDTO = _mapper.Map <Game, GameDTOs>(game);
                return(new ServiceResult(payload: recallGameDTO));
            }
            catch (DbUpdateConcurrencyException e)
            {
                if (!GameExists(id))
                {
                    throw new NotFoundException(nameof(savedGameDTOs), id);
                }
                return(new ServiceResult(false, message: e.Message));
            }
        }
        public void PostNewGameController(string name, string publisherId,
                                          string members1, string members2,
                                          string favoriteMembers1, string favoriteMembers2,
                                          float rating, string logo,
                                          string videoUrl, string content,
                                          string categories1, string categories2,
                                          float price,
                                          EventHandler callback = null)
        {
            //    Init(49914);

            SavedGameDTOs savedGameDTOs = new SavedGameDTOs()
            {
                Name            = name,
                PublisherId     = publisherId.ToGuid(),
                Members         = new Collection <Guid> {
                },
                FavoriteMembers = new Collection <Guid> {
                },
                Rating          = rating,
                Logo            = logo,
                VideoUrl        = videoUrl,
                Content         = content,
                Categories      = new Collection <Guid> {
                },
                Price           = price,
                PurchaseDate    = DateTime.Now
            };

            using (HttpClient client = new HttpClient())
            {
                client.BaseAddress = BASE_URI;
                HttpResponseMessage result       = client.PostAsJsonAsync($"api/games", savedGameDTOs).Result;
                var contentResult                = result.Content.ReadAsStringAsync().Result;
                Response <GameDTOs> gameResponse = JsonConvert.DeserializeObject <Response <GameDTOs> >(contentResult);
                callback.Invoke(null, new GameEventArgs(gameResponse.Payload.Id));
            }
        }