public async Task <IActionResult> Edit(int id, [Bind("IsBanned,BanReason,IsDeleted,DeletedOn,CreatedOn,ModifiedOn,Id,UserName,NormalizedUserName,Email,NormalizedEmail,EmailConfirmed,PasswordHash,SecurityStamp,ConcurrencyStamp,PhoneNumber,PhoneNumberConfirmed,TwoFactorEnabled,LockoutEnd,LockoutEnabled,AccessFailedCount")] User user)
{
if (id != user.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{ if (user.IsDeleted)
{
user.DeletedOn = DateTime.Now;
}
user.ModifiedOn = DateTime.Now;
_context.Update(user);
await _context.SaveChangesAsync(); }
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Create([Bind("FirstName,LastName,DateOfBirth,CreatedOn,isBanned,banDescription,Id,UserName,NormalizedUserName,Email,NormalizedEmail,EmailConfirmed,PasswordHash,SecurityStamp,ConcurrencyStamp,PhoneNumber,PhoneNumberConfirmed,TwoFactorEnabled,LockoutEnd,LockoutEnabled,AccessFailedCount")] User user)
{
if (ModelState.IsValid)
{
_context.Add(user);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Create([Bind("Id,Name,CreatedOn,ModifiedOn,IsDeleted,DeletedOn")] BeerType beerType)
{
if (ModelState.IsValid)
{
_context.Add(beerType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(beerType));
}
public async Task <IActionResult> Create([Bind("Id,Name,CountryId,IsDeleted,DeletedOn,CreatedOn,ModifiedOn")] Brewery brewery)
{
if (ModelState.IsValid)
{
_context.Add(brewery);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CountryId"] = new SelectList(_context.Countries, "Id", "Name", brewery.CountryId);
return(View(brewery));
}
public async Task <IActionResult> Create([Bind("Id,Rating,Name,Text,TargetBeerId,AuthorId,ModifiedOn,IsDeleted,DeletedOn")] Review review)
{
if (ModelState.IsValid)
{
_context.Add(review);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AuthorId"] = new SelectList(_context.Users, "Id", "Email", review.AuthorId);
ViewData["TargetBeerId"] = new SelectList(_context.Beers, "Id", "Name", review.TargetBeerId);
return(View(review));
}
public async Task <IActionResult> Create([Bind("Id,Name,TypeId,BreweryId,CreatedOn,DeletedOn,ModifiedOn,IsDeleted,AlcoholByVolume")] Beer beer)
{
if (ModelState.IsValid)
{
_context.Add(beer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BreweryId"] = new SelectList(_context.Breweries, "Id", "Name", beer.BreweryId);
ViewData["TypeId"] = new SelectList(_context.BeerTypes, "Id", "Name", beer.TypeId);
return(View(beer));
}
public async Task <CountryDTO> CreateCountryAsync(CountryDTO countryDTO)
{
var country = new Country
{
Id = countryDTO.Id,
Name = countryDTO.Name,
};
await _beerOverflowContext.Countries.AddAsync(country);
await _beerOverflowContext.SaveChangesAsync();
return(countryDTO);
}
public async Task <ReviewDTO> AddReviewAsync(string userName, string beerName, int rating, string rMessage)
{
var user = await _beerOverflowContext.Users.FirstOrDefaultAsync(u => u.UserName == userName);
if (user == null)
{
throw new ArgumentNullException("User is null!");
}
var beer = await _beerOverflowContext.Beers
.Where(b => b.DateUnlisted == null)
.FirstOrDefaultAsync(b => b.BeerName == beerName);
if (beer == null)
{
throw new ArgumentNullException("Beer is null!");
}
if (rating < 1 || rating > 5)
{
throw new ArgumentOutOfRangeException("Rating is out of range!");
}
var userReview = new Review
{
UserId = user.Id,
BeerId = beer.Id,
Rating = rating,
RMessage = rMessage,
ReviewedOn = DateTime.UtcNow
};
try
{
await _beerOverflowContext.Reviews.AddAsync(userReview);
await _beerOverflowContext.SaveChangesAsync();
}
catch (Exception)
{
throw new InvalidOperationException("Cannot add into database!");
}
var userReviewDTO = new ReviewDTO(userReview.Id, userReview.RMessage, userReview.Rating,
userReview.User.UserName, userReview.UserId, userReview.Beer.BeerName,
userReview.BeerId, userReview.ReviewedOn);
return(userReviewDTO);
}
public async Task <BreweryDTO> CreateBreweryAsync(BreweryDTO breweryDTO)
{
var brewery = new Brewery
{
Id = breweryDTO.Id,
Name = breweryDTO.Name,
Description = breweryDTO.Description,
CountryId = breweryDTO.CountryId,
};
_beerOverflowContext.Breweries.Add(brewery);
await _beerOverflowContext.SaveChangesAsync();
return(breweryDTO);
}
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));
}
public async Task <UserBeersDTO> AddBeerToDrankListAsync(string userName, string beerName)
{
var user = await _beerOverflowContext.Users.FirstOrDefaultAsync(u => u.UserName == userName);
if (user == null)
{
throw new ArgumentNullException("User is null!");
}
var beer = await _beerOverflowContext.Beers.FirstOrDefaultAsync(b => b.BeerName == beerName);
if (beer == null)
{
throw new ArgumentNullException("Beer is null!");
}
var userBeer = await _beerOverflowContext.UserBeers
.Where(ub => ub.UserId == user.Id)
.FirstOrDefaultAsync(ub => ub.BeerId == beer.Id);
if (userBeer == null)
{
var newUserBeer = new UserBeers
{
UserId = user.Id,
BeerId = beer.Id,
DrankOn = DateTime.UtcNow
};
_beerOverflowContext.UserBeers.Add(newUserBeer);
await _beerOverflowContext.SaveChangesAsync();
}
else
{
if (userBeer.DrankOn == null)
{
userBeer.DrankOn = DateTime.UtcNow;
await _beerOverflowContext.SaveChangesAsync();
}
else
{
throw new ArgumentException("Already drank this beer!");
}
}
var userBeerDTO = new UserBeersDTO(user.UserName, user.Id,
beer.BeerName, beer.Id, userBeer.DrankOn);
return(userBeerDTO);
}
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;
}
}
public async Task <UserDTO> CreateUserAsync(UserDTO userDTO)
{
var user = new User
{
Id = userDTO.Id,
UserName = userDTO.Username,
FirstName = userDTO.FirstName,
LastName = userDTO.LastName,
Email = userDTO.Email,
CreatedOn = DateTime.UtcNow
};
_beerOverflowContext.Users.Add(user);
await _beerOverflowContext.SaveChangesAsync();
return(userDTO);
}
public async Task <IActionResult> Create([Bind("UserId,BeerId")] BeerDrank beerDrank)
{
if (ModelState.IsValid)
{
var beersDrankExists = _context.BeersDrank.FirstOrDefault(wb => wb.UserId == beerDrank.UserId && wb.BeerId == beerDrank.BeerId);
if (beersDrankExists == null)
{
_context.Add(beerDrank);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BeerId"] = new SelectList(_context.Beers, "Id", "Name", beerDrank.BeerId);
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", beerDrank.UserId);
return(View(beerDrank));
}
public async Task <IActionResult> Create([Bind("UserId,BeerId")] WishlistBeer wishlistBeer)
{
if (ModelState.IsValid)
{
var wishlistBeerExists = _context.WishlistBeers.FirstOrDefault(wb => wb.UserId == wishlistBeer.UserId && wb.BeerId == wishlistBeer.BeerId);
if (wishlistBeerExists == null)
{
_context.Add(wishlistBeer);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BeerId"] = new SelectList(_context.Beers, "Id", "Name", wishlistBeer.BeerId);
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", wishlistBeer.UserId);
return(View(wishlistBeer));
}
public async Task <BeerTypeDTO> CreateBeerTypeAsync(BeerTypeDTO beerTypeDTO)
{
try
{
var beerType = new BeerType
{
Type = beerTypeDTO.Type,
Description = beerTypeDTO.Description,
};
await _beerOverflowContext.BeerTypes.AddAsync(beerType);
await _beerOverflowContext.SaveChangesAsync();
return(beerTypeDTO);
}
catch (Exception)
{
throw;
}
}
