Beispiel #1
0
        public Beer updateBeer(BeerDTO newbeer)
        {
            var beerInDataBase = getBeerById(newbeer.id);

            if (beerInDataBase == null)
            {
                return(null);
            }

            beerInDataBase.Name             = newbeer.name;
            beerInDataBase.Tagline          = newbeer.tagline;
            beerInDataBase.FirstBrewed      = newbeer.first_brewed;
            beerInDataBase.Description      = newbeer.description;
            beerInDataBase.Abv              = newbeer.abv;
            beerInDataBase.Ibu              = newbeer.ibu;
            beerInDataBase.TargetFg         = newbeer.target_fg;
            beerInDataBase.TargetOg         = newbeer.target_og;
            beerInDataBase.Ebc              = newbeer.ebc;
            beerInDataBase.Srm              = newbeer.srm;
            beerInDataBase.Ph               = newbeer.ph;
            beerInDataBase.AttenuationLevel = newbeer.attenuation_level;
            beerInDataBase.Food             = null; //Sorry sé que después debo encontrar como hacerlo
            beerInDataBase.BrewersTips      = newbeer.brewers_tips;
            beerInDataBase.ContributedBy    = newbeer.contributed_by;

            dataBase.SaveChanges();

            return(beerInDataBase);
        }
Beispiel #2
0
 public static Beer MapDTOToBeer(this BeerDTO dto)
 {
     try
     {
         var beer = new Beer()
         {
             ID        = dto.ID,
             Name      = dto.Name,
             Rating    = dto.Rating,
             ABV       = dto.ABV,
             IsDeleted = dto.IsDeleted,
             CountryID = dto.CountryID,
             //Country = new Country() { Name = dto.Country.Name},//dto.Country.MapDTOToCountry(),
             StyleID = dto.StyleID,
             //Style = new BeerStyle() {Name = dto.Style.Name },//dto.Style.MapDTOToStyle(),
             BreweryID = dto.BreweryID,
             //Brewery = new Brewery() { Name = dto.Brewery.Name, Country = new Country() { Name = dto.Brewery.Country} },//dto.Brewery.MapDTOToBrewery()
         };
         if (dto.Reviews != null)
         {
             beer.Reviews = dto.Reviews.Select(r => r.MapDTOToReview()).ToList();
         }
         else
         {
             beer.Reviews = null;
         }
         return(beer);
     }
     catch (Exception)
     {
         return(new Beer());
     }
 }
        public void MapDTOToBeer_ShouldReturnCorrectID()
        {
            //Arrange
            var cut = new BeerDTO
            {
                ID      = 1,
                ABV     = 4.5f,
                Rating  = 2,
                Name    = "Carlsberg",
                Country = new CountryDTO()
                {
                    Name = "Bulgaria"
                },
                Brewery = new BreweryDTO()
                {
                    Name = "Brewery", Country = "Germany"
                },
                Style = new BeerStyleDTO()
                {
                    Name = "Ale"
                }
            };
            //Act
            var sut = cut.MapDTOToBeer();

            //Assert
            Assert.AreEqual(sut.ID, 1);
        }
        public void MapDTOToBeer_ShouldReturnCorrectNameAndCountryAndBreweryAndStyle()
        {
            //Arrange
            var cut = new BeerDTO
            {
                ABV     = 4.5f,
                Rating  = 2,
                Name    = "Carlsberg",
                Country = new CountryDTO()
                {
                    Name = "Bulgaria"
                },
                Brewery = new BreweryDTO()
                {
                    Name = "Brewery", Country = "Germany"
                },
                Style = new BeerStyleDTO()
                {
                    Name = "Ale"
                }
            };
            //Act
            var sut = cut.MapDTOToBeer();

            //Assert
            Assert.AreEqual(sut.Name, "Carlsberg");
            Assert.AreEqual(sut.Country.Name, "Bulgaria");
            Assert.AreEqual(sut.Brewery.Name, "Brewery");
            Assert.AreEqual(sut.Brewery.Country.Name, "Germany");
            Assert.AreEqual(sut.Style.Name, "Ale");
            Assert.AreEqual(sut.ABV, 4.5f);
            Assert.AreEqual(sut.Rating, 2);
        }
        public void MapDTOToBeer_ShouldReturnBrewery()
        {
            //Arrange
            var cut = new BeerDTO
            {
                ID      = 1,
                ABV     = 4.5f,
                Rating  = 2,
                Name    = "Carlsberg",
                Country = new CountryDTO()
                {
                    Name = "Bulgaria"
                },
                Brewery = new BreweryDTO()
                {
                    Name = "Brewery", Country = "Germany"
                },
                Style = new BeerStyleDTO()
                {
                    Name = "Ale"
                }
            };
            //Act
            var sut = cut.MapDTOToBeer();

            //Assert
            Assert.IsInstanceOfType(sut, typeof(Beer));
        }
        public async Task ThrowNullExc_If_BeerAlreadyExists()
        {
            var options      = TestUtils.GetOptions(nameof(ThrowNullExc_If_BeerAlreadyExists));
            var mockDateTime = new Mock <IDateTimeProvider>();

            var beer = new Beer
            {
                Name = "Ariana"
            };

            var beerDTO = new BeerDTO
            {
                Name = "Ariana"
            };

            using (var arrangeContext = new BeeroverflowContext(options))
            {
                await arrangeContext.Beers.AddAsync(beer);

                await arrangeContext.SaveChangesAsync();
            }

            using (var assertContext = new BeeroverflowContext(options))
            {
                var sut = new BeerService(assertContext, mockDateTime.Object);

                await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBeerAsync(beerDTO));
            }
        }
Beispiel #7
0
        public BeerDTO GetBeer(int id)
        {
            var beer = _context.Beers
                       .Include(b => b.Type)
                       .Include(b => b.Brewery)
                       .ThenInclude(br => br.Country)
                       .FirstOrDefault(b => b.Id == id);

            if (beer == null)
            {
                throw new ArgumentNullException();
            }

            var beerDTO = new BeerDTO
            {
                Id              = beer.Id,
                Name            = beer.Name,
                BeerType        = beer.Type.Name,
                Brewery         = beer.Brewery.Name,
                BreweryCountry  = beer.Brewery.Country.Name,
                AlcoholByVolume = beer.AlcoholByVolume,
            };

            return(beerDTO);
        }
Beispiel #8
0
        public Beer addBeer(BeerDTO newbeer)
        {
            var newBeerInDB = new Beer();

            newBeerInDB.Name             = newbeer.name;
            newBeerInDB.Tagline          = newbeer.tagline;
            newBeerInDB.FirstBrewed      = newbeer.first_brewed;
            newBeerInDB.Description      = newbeer.description;
            newBeerInDB.Abv              = newbeer.abv;
            newBeerInDB.Ibu              = newbeer.ibu;
            newBeerInDB.TargetFg         = newbeer.target_fg;
            newBeerInDB.TargetOg         = newbeer.target_og;
            newBeerInDB.Ebc              = newbeer.ebc;
            newBeerInDB.Srm              = newbeer.srm;
            newBeerInDB.Ph               = newbeer.ph;
            newBeerInDB.AttenuationLevel = newbeer.attenuation_level;
            newBeerInDB.Food             = null; //Sorry sé que después debo encontrar como hacerlo
            newBeerInDB.BrewersTips      = newbeer.brewers_tips;
            newBeerInDB.ContributedBy    = newbeer.contributed_by;

            dataBase.Beer.Add(newBeerInDB);
            dataBase.SaveChanges();

            return(newBeerInDB);
        }
Beispiel #9
0
        /// <summary>
        /// Updates the Beer's Name, Style, Brewery and Country
        /// </summary>
        /// <param name="id">ID of the Beer to be updated.</param>
        /// <param name="model">Input object with update information.</param>
        /// <returns>Returns the reevaluated input object</returns>
        public async Task <BeerDTO> UpdateAsync(int?id, BeerDTO model)
        {
            var beer = await this._context.Beers
                       .Include(b => b.Country)
                       .Include(b => b.Style)
                       .Include(b => b.Brewery)
                       .FirstOrDefaultAsync(br => br.ID == id);

            if (beer == null)
            {
                return(null);
            }
            beer.ABV        = model.ABV;
            beer.Name       = model.Name;
            beer.Country    = _context.Countries.FirstOrDefault(c => c.Name == model.Country.Name);
            beer.Style      = _context.BeerStyles.FirstOrDefault(s => s.Name == model.Style.Name);
            beer.Brewery    = _context.Breweries.FirstOrDefault(b => b.Name == model.Brewery.Name);
            beer.ModifiedOn = DateTime.UtcNow;
            model.ID        = beer.ID;
            _context.Beers.Update(beer);
            try
            {
                await this._context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BeerExists(id))
                {
                    return(null);
                }
            }
            return(model);
        }
        public void CreateBeer_Success()
        {
            //Arrange
            var beerDTO = new BeerDTO
            {
                BeerName    = "Boliarka",
                BeerTypeId  = 1,
                BreweryId   = 1,
                AlcByVol    = (double)3.2,
                Description = "Stava",
            };
            var options = Utils.GetOptions(nameof(CreateBeer_Success));

            //Act & Assert
            using (var assertContext = new BeerOverflowContext(options))
            {
                var sut    = new BeerService(assertContext);
                var result = sut.CreateBeer(beerDTO);
                Assert.AreEqual(beerDTO.BeerName, result.BeerName);
                Assert.AreEqual(beerDTO.BeerTypeId, result.BeerTypeId);
                Assert.AreEqual(beerDTO.BreweryId, result.BreweryId);
                Assert.AreEqual(beerDTO.AlcByVol, result.AlcByVol);
                Assert.AreEqual(beerDTO.Description, result.Description);
            }
        }
        public void Save(BeerDTO beerDTO)
        {
            //_context.Database.BeginTransaction();

            if (beerDTO.Id.HasValue)
            {
                var beerModel = _beerRepository.GetById(beerDTO.Id.Value);
                if (beerModel == null)
                {
                    //_context.Database.RollbackTransaction();
                    throw new NotFoundException("L'identifiant de la bière n'est pas valide!");
                }

                beerModel.Name = beerDTO.Name;
                beerModel.Type = beerDTO.Type;

                _beerRepository.Edit(beerModel);
            }
            else
            {
                var beerModel = new Beer()
                {
                    Id           = null,
                    CreationDate = DateTime.Now,
                    Name         = beerDTO.Name,
                    Type         = beerDTO.Type
                };

                _beerRepository.Create(beerModel);
            }

            //_context.Database.CommitTransaction();
        }
        public async Task <IActionResult> Put(int id, [FromBody] BeerDTO beer)
        {
            if (beer == null)
            {
                return(BadRequest());
            }
            var theNewBeer = await this._service.UpdateAsync(id, beer);

            return(Ok(theNewBeer));
        }
        public async Task <IActionResult> Post([FromBody] BeerDTO beer)
        {
            if (beer == null)
            {
                return(BadRequest());
            }
            var theNewBeer = await this._service.CreateAsync(beer);

            return(Created("Post", theNewBeer));
        }
Beispiel #14
0
        public async Task SaveRating([FromBody] RatingDTO dto)
        {
            ///
            /// Persist RatingDTO
            /// To Query the existing data using the beerid
            /// If Found update, if not Insert
            ///
            var row = data.Where(x => x.id == dto.beerid).FirstOrDefault();

            if (row == null)
            {
                BeerWithRatingsDTO temp = new BeerWithRatingsDTO();
                temp.comments.Add(new RatingShortDTO()
                {
                    username = dto.username, userrating = dto.userrating, comment = dto.comment
                });

                ///////////////////////
                //Need to populate temp's Beer Information using Punk API!!!!
                ///////////////////////
                BeerDTO beer = await new PunkRepository().GetBeersById(dto.beerid);
                temp.name        = beer.name;
                temp.description = beer.description;

                data.Add(temp);
            }
            else ////row!=null
            {
                var comment = row.comments.Where(x => x.username == dto.username).FirstOrDefault();

                if (comment == null)
                {
                    row.comments.Add(new RatingShortDTO()
                    {
                        username = dto.username, userrating = dto.userrating, comment = dto.comment
                    });
                }
                else
                {
                    comment.username   = dto.username;
                    comment.userrating = dto.userrating;
                    comment.comment    = dto.comment;
                }
            }

            //persist the data back into File
            string newString = JsonConvert.SerializeObject(data, Formatting.Indented);

            File.WriteAllText("data.json", newString);

            ///////////////////////
            ///Need to ask BeerWithRatingsControler to reload!
            ///////////////////////
            BeerWithRatingsController.ReloadDataFromFile();
        }
Beispiel #15
0
        public ActionResult Update(int id, [FromBody] BeerDTO beer)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Invalid Model"));
            }

            _beerService.Save(beer);

            return(Ok());
        }
Beispiel #16
0
 public void UpdateBeer_BeerName_Success()
 {
     //Arange, Act & Assert
     using (var assertContext = Utils.GetContextWithData(nameof(UpdateBeer_BeerName_Success)))
     {
         var     id           = 1;
         var     sut          = new BeerService(assertContext);
         var     oldName      = sut.GetBeer(id).BeerName;
         var     nameToUpdate = "Gayda";
         BeerDTO result       = sut.UpdateBeer(id, nameToUpdate, null, null, 1, 1);
         Assert.AreNotEqual(oldName, nameToUpdate);
     }
 }
Beispiel #17
0
        public async Task <BeerDTO> CreateBeerAsync(BeerDTO beerDTO)
        {
            var check = await this.context.Beers
                        .FirstOrDefaultAsync(x => x.Name == beerDTO.Name);

            if (check != null)
            {
                throw new ArgumentNullException("Beer already exist.");
            }

            var brewery = await this.context.Breweries
                          .Include(x => x.Country)
                          .Where(x => x.Name == beerDTO.Brewery)
                          .FirstOrDefaultAsync();

            if (brewery == null)
            {
                throw new ArgumentNullException("Brewery does not exist.");
            }

            var country = brewery.Country;

            var style = await this.context.Styles
                        .Where(x => x.Name == beerDTO.Style)
                        .FirstOrDefaultAsync();

            if (style == null)
            {
                throw new ArgumentNullException("Style does not exist.");
            }

            var beer = new Beer
            {
                Id        = beerDTO.Id,
                Name      = beerDTO.Name,
                Abv       = beerDTO.Abv,
                BreweryId = brewery.Id,
                CountryId = country.Id,
                StyleId   = style.Id,
                CreatedOn = this.dateTimeProvider.GetDateTime(),
            };

            await this.context.Beers.AddAsync(beer);

            await this.context.SaveChangesAsync();

            beerDTO.Id = beer.Id;
            return(beerDTO);
        }
Beispiel #18
0
        public async Task <IActionResult> Create([FromBody] BeerViewModel model)
        {
            try
            {
                var beerDto = new BeerDTO(model.BeerName, model.BeerTypeId,
                                          model.BreweryId, (double)model.AlcByVol, model.Description);
                var beer = await this.beerService.CreateBeerAsync(beerDto);

                return(Created("Post", beer));
            }
            catch (Exception)
            {
                throw;
            }
        }
Beispiel #19
0
 public BeerDTO CreateBeer(BeerDTO beerDTO)
 {
     try
     {
         var beer = new Beer(beerDTO.BeerName, beerDTO.BeerTypeId, beerDTO.BreweryId,
                             beerDTO.AlcByVol, beerDTO.Description);
         _beerOverflowContext.Beers.Add(beer);
         _beerOverflowContext.SaveChanges();
         return(beerDTO);
     }
     catch (Exception)
     {
         throw;
     }
 }
        public async Task CreateBeer_When_ParamsAreValid()
        {
            var options      = TestUtils.GetOptions(nameof(CreateBeer_When_ParamsAreValid));
            var mockDateTime = new Mock <IDateTimeProvider>();

            var country = new Country
            {
                Name = "Romania"
            };
            var brewery = new Brewery
            {
                Name      = "Ariana",
                CountryId = 1
            };
            var style = new Style
            {
                Name = "Pale"
            };

            var beerDTO = new BeerDTO
            {
                Name    = "Birichka",
                Country = "Romania",
                Brewery = "Ariana",
                Style   = "Pale"
            };

            using (var arrangeContext = new BeeroverflowContext(options))
            {
                await arrangeContext.Countries.AddAsync(country);

                await arrangeContext.Breweries.AddAsync(brewery);

                await arrangeContext.Styles.AddAsync(style);

                await arrangeContext.SaveChangesAsync();
            }

            using (var assertContext = new BeeroverflowContext(options))
            {
                var sut    = new BeerService(assertContext, mockDateTime.Object);
                var result = await sut.CreateBeerAsync(beerDTO);

                var comparison = assertContext.Beers.Where(x => x.Id == 1).FirstOrDefault();

                Assert.AreEqual("Birichka", comparison.Name);
            }
        }
Beispiel #21
0
        public async Task <IActionResult> Create([Bind("BeerName,AlcByVol,Description,BeerTypeId,BreweryId")] BeerViewModel model)
        {
            if (ModelState.IsValid)
            {
                var beerDto = new BeerDTO(model.BeerName, model.BeerTypeId, model.BreweryId, (double)model.AlcByVol, model.Description);
                var beer    = beerService.CreateBeer(beerDto);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["BeerTypeId"] = new SelectList(_context.BeerTypes, "Id", "Type");
            ViewData["BreweryId"]  = new SelectList(_context.Breweries, "Id", "Name");
            ViewData["CountryId"]  = new SelectList(_context.Countries, "Id", "Name");

            return(View(model));
        }
Beispiel #22
0
        public async Task <BeerDTO> CreateBeerAsync(BeerDTO beerDTO)
        {
            try
            {
                var beer = new Beer(beerDTO.BeerName, beerDTO.BeerTypeId, beerDTO.BreweryId,
                                    beerDTO.AlcByVol, beerDTO.Description);
                await _beerOverflowContext.Beers.AddAsync(beer);

                await _beerOverflowContext.SaveChangesAsync();

                return(beerDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }
Beispiel #23
0
 private bool MatchesSearch(BeerDTO beer, SearchBeerDTO searchData)
 {
     if (!String.IsNullOrWhiteSpace(searchData.Name))
     {
         if (!beer.Name.ToLower().Contains(searchData.Name.ToLower()))
         {
             return(false);
         }
     }
     return(((searchData.Style != null && beer.Style != searchData.Style) ||
             beer.Alcohol < searchData.AlcoholMin ||
             beer.Alcohol > searchData.AlcoholMax ||
             beer.Ibu < searchData.IbuMin ||
             beer.Ibu > searchData.IbuMax ||
             beer.Blg < searchData.BlgMin ||
             beer.Blg > searchData.BlgMax) ? false : true);
 }
        public async Task ThrowNullExcFroBeer_If_StyleDoesNotExist()
        {
            var options      = TestUtils.GetOptions(nameof(ThrowNullExcFroBeer_If_StyleDoesNotExist));
            var mockDateTime = new Mock <IDateTimeProvider>();

            var country = new Country
            {
                Name = "Romania"
            };
            var brewery = new Brewery
            {
                Name      = "Ariana",
                CountryId = 1
            };
            var style = new Style
            {
                Name = "Pale"
            };

            var beerDTO = new BeerDTO
            {
                Name    = "Birichka",
                Country = "Romania",
                Brewery = "Ariana",
                Style   = "Dark Lager"
            };

            using (var arrangeContext = new BeeroverflowContext(options))
            {
                await arrangeContext.Countries.AddAsync(country);

                await arrangeContext.Breweries.AddAsync(brewery);

                await arrangeContext.Styles.AddAsync(style);

                await arrangeContext.SaveChangesAsync();
            }

            using (var assertContext = new BeeroverflowContext(options))
            {
                var sut = new BeerService(assertContext, mockDateTime.Object);

                await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateBeerAsync(beerDTO));
            }
        }
        public static BeerViewModel MapBeerDTOToView(this BeerDTO dto)
        {
            var beerView = new BeerViewModel()
            {
                ID        = dto.ID,
                Name      = dto.Name,
                Style     = dto.Style.Name,
                Country   = dto.Country.Name,
                Brewery   = dto.Brewery.Name,
                Rating    = dto.Rating,
                ABV       = dto.ABV,
                IsDeleted = dto.IsDeleted,
            };

            if (dto.Reviews != null)
            {
                beerView.Reviews = dto.Reviews.Select(r => r.MapDTOToReviewView()).ToList();
            }
            return(beerView);
        }
        public async Task <IActionResult> Rate(int id, [FromBody] BeerDTO beerDTO)
        {
            var beerID = beerDTO.ID;

            if (id <= 0 || beerID == default)
            {
                return(BadRequest());
            }

            try
            {
                var model = await this._service.Rate(id, beerDTO.ID, (int)beerDTO.Rating);

                return(Ok(model));
            }
            catch (Exception e)
            {
                return(NotFound(e.Message));
            }
        }
        public async Task <IActionResult> Post([FromBody] BeerViewModel model)
        {
            if (model == null)
            {
                return(BadRequest());
            }

            var beerDTO = new BeerDTO
            {
                Id      = model.Id,
                Name    = model.Name,
                Abv     = model.Abv,
                Country = model.Country,
                Brewery = model.Brewery,
                Style   = model.Style
            };

            var newBeer = await this.beerService.CreateBeerAsync(beerDTO);

            return(Created("Post", newBeer));
        }
        public IActionResult Post([FromBody] BeerViewModel beerViewModel)
        {
            if (beerViewModel == null)
            {
                return(BadRequest());
            }
            if (BeerExists(beerViewModel.Name))
            {
                return(ValidationProblem($"Beer with name {beerViewModel.Name} already exists."));
            }
            var beerDTO = new BeerDTO
            {
                Name            = beerViewModel.Name,
                BeerType        = beerViewModel.BeerType,
                Brewery         = beerViewModel.Brewery,
                AlcoholByVolume = beerViewModel.AlcoholByVolume
            };
            var beer = _beerService.CreateBeer(beerDTO);

            return(Created("Post", beerViewModel));
        }
 public static BeerViewModel GetViewModel(this BeerDTO dto)
 {
     if (dto == null)
     {
         throw new ArgumentException();
     }
     ;
     return(new BeerViewModel
     {
         Id = dto.Id,
         Name = dto.Name,
         Abv = dto.Abv,
         CountryId = dto.CountryId,
         Country = dto.Country,
         BreweryId = dto.BreweryId,
         Brewery = dto.Brewery,
         StyleId = dto.StyleId,
         Style = dto.Style,
         Rating = Math.Round(dto.Rating, 2),
         Reviews = dto.Reviews.GetViewModels()
     });
 }
Beispiel #30
0
 public static BeerDTO MapBeerToDTO(this Beer beer)
 {
     try
     {
         var beerDTO = new BeerDTO
         {
             ID        = beer.ID,
             Name      = beer.Name,
             Rating    = beer.Rating,
             ABV       = beer.ABV,
             IsDeleted = beer.IsDeleted,
             Country   = new CountryDTO()
             {
                 Name = beer.Country.Name
             },                                                       //beer.Country.MapCountryToDTO(),
             Style = new BeerStyleDTO()
             {
                 Name = beer.Style.Name
             },                                                    //beer.Style.MapStyleToDTO(),
             Brewery = new BreweryDTO()
             {
                 Name = beer.Brewery.Name, Country = beer.Brewery.Country.Name
             }                                                                                           //beer.Brewery.MapBreweryToDTO(),
         };
         if (beer.Reviews != null)
         {
             beerDTO.Reviews = beer.Reviews.Select(r => r.MapReviewToDTO()).ToList();
         }
         else
         {
             beerDTO.Reviews = null;
         }
         return(beerDTO);
     }
     catch (Exception)
     {
         return(new BeerDTO());
     }
 }