/// <summary>
/// This method adds the new Bar to the DataBase after checking if it does not exists already
/// </summary>
/// <param name="barToCreate">This is the newly created Bar object</param>
/// <returns>Task</returns>
public async Task CreateBar(BarDTO barToCreate)
{
try
{
var barToAdd = _barFactory.CreateNewBar(barToCreate.Name, barToCreate.Address, barToCreate.Information, barToCreate.Picture, barToCreate.MapDirection);
var barToFind = _context.Bars.SingleOrDefault(bar => bar.Name == barToAdd.Name && bar.Address == barToAdd.Address && !bar.IsDeleted);
if (barToFind != null)
{
throw new InvalidOperationException("Bar already exists in the database!");
}
await _context.Bars.AddAsync(barToAdd);
await _context.SaveChangesAsync();
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Bar already exists in the database!");
}
catch (Exception)
{
throw new Exception("Wrong parameters for Bar!");
}
}
public async Task <CocktailDTO> Create(CocktailDTO cocktailDTO)
{
if (this.context.Bars.Any(b => b.Name == cocktailDTO.Name))
{
throw new ArgumentException("The name is already existing");
}
if (cocktailDTO.Name == null)
{
throw new ArgumentNullException("The name is mandatory");
}
var cocktail = new Cocktail
{
Id = cocktailDTO.Id,
AlcoholPercentage = cocktailDTO.AlcoholPercentage,
Bars = cocktailDTO.Bars,
Comments = cocktailDTO.Comments,
ImageURL = cocktailDTO.ImageURL,
Ingredients = cocktailDTO.Ingredients,
IsAlcoholic = cocktailDTO.IsAlcoholic,
Name = cocktailDTO.Name,
Rating = cocktailDTO.Rating,
Stars = cocktailDTO.Stars
};
await context.Cocktails.AddAsync(cocktail);
await context.SaveChangesAsync();
return(cocktail.Map());
}
/// <summary>
/// Adds the new bar to the database after checking if it does not exists already.
/// </summary>
/// <param name="barToCreate">This is the newly created Bar object</param>
/// <returns>BarDTO</returns>
public async Task <BarDTO> CreateBar(BarDTO barDTO)
{
if (this.context.Bars.Any(b => b.Name == barDTO.Name))
{
throw new ArgumentException(Exceptions.NameExists);
}
if (barDTO.Name == null)
{
throw new ArgumentNullException(Exceptions.MissingName);
}
var country = await this.context.Countries
.Where(c => c.IsDeleted == false)
.FirstOrDefaultAsync(c => c.Id == barDTO.CountryId || c.Name == barDTO.CountryName)
?? throw new ArgumentNullException(Exceptions.EntityNotFound);
var bar = barDTO.GetEntity();
await context.Bars.AddAsync(bar);
await context.SaveChangesAsync();
return(bar.GetDTO());
}
public async Task <IActionResult> Create(CqasPersona ascqpersona)
{
Response response = new Response();
try
{
if (ascqpersona.FechaNacimiento > DateTime.Now)
{
Combox();
InicializarMensaje("Fecha de nacimiento incorrecta");
return(View(ascqpersona));
}
if (!ExistePersona(ascqpersona))
{
_context.CqasPersona.Add(ascqpersona);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
Combox();
InicializarMensaje("Numero de cedula registrada");
return(View(ascqpersona));
}
catch (Exception ex)
{
Combox();
return(View(ascqpersona));
}
}
public async Task <Bar> Create(BarDTO barDTO)
{
if (this.context.Bars.Any(b => b.Name == barDTO.Name))
{
throw new ArgumentException("The name is already existing");
}
if (barDTO.Name == null)
{
throw new ArgumentNullException("The name is mandatory");
}
var bar = new Bar
{
Name = barDTO.Name,
Country = barDTO.Country,
City = barDTO.City,
Address = barDTO.Address,
Phone = barDTO.Phone,
Cocktails = barDTO.Cocktails,
ImageURL = barDTO.ImageURL,
CreatedOn = DateTime.UtcNow
};
await context.Bars.AddAsync(bar);
await context.SaveChangesAsync();
return(bar);
}
public async Task <CityDTO> CreateCityAsync(CityDTO cityDTO)
{
var city = cityDTO.CityDTOMapToModel();
await _cmContext.AddAsync(city);
await _cmContext.SaveChangesAsync();
return(cityDTO);
}
public async Task AddIngredient(IngredientDTO ingredientDto) //tested
{
ingredientDto.ValidateIfNull(ExceptionMessages.IngredientDtoNull);
var ingredientCtx = ingredientDto.MapToCtxModel();
ingredientCtx.ValidateIfNull(ExceptionMessages.IngredientNull);
_context.Add(ingredientCtx);
await _context.SaveChangesAsync();
}
public async Task SetProfilePictureURL(string userId, string url) //tested
{
userId.ValidateIfNull(ExceptionMessages.IdNull);
var user = await _context.Users.Where(u => u.Id == userId && u.DateDeleted == null)
.FirstOrDefaultAsync();
user.ValidateIfNull(ExceptionMessages.AppUserNull);
user.ImageURL = url;
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Create([Bind("ID,Name,DateOfBirth,Notes")] Professor professor)
{
if (ModelState.IsValid)
{
_context.Add(professor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(professor));
}
public async Task <IActionResult> Create([Bind("ID,Name,Description")] University university)
{
if (ModelState.IsValid)
{
_context.Add(university);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(university));
}
public async Task <IActionResult> Create([Bind("ID,Name,Content,UniversityID")] StudyPlan studyPlan)
{
if (ModelState.IsValid)
{
_context.Add(studyPlan);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UniversityID"] = new SelectList(_context.Universities, "ID", "ID", studyPlan.UniversityID);
return(View(studyPlan));
}
public async Task <CocktailReviewLikeDTO> AddCocktailReviewLike(Guid cocktailReviewId, string userName)
{
var cReview = await _cmContext.CocktailReviews
.FirstOrDefaultAsync(cr => cr.Id == cocktailReviewId);
if (cReview == null)
{
throw new ArgumentNullException("Cocktail review not found!");
}
var user = await _cmContext.Users
.FirstOrDefaultAsync(u => u.UserName == userName);
if (user == null)
{
throw new ArgumentNullException("User not found!");
}
var cocktailReviewLike = await _cmContext.CocktailReviewLikes
.FirstOrDefaultAsync(cr => cr.CocktailReviewId == cocktailReviewId && cr.UserId == user.Id);
if (cocktailReviewLike == null)
{
var cocktailReviewLikeNew = new CocktailReviewLike
{
CocktailReviewId = cReview.Id,
UserId = user.Id,
IsLiked = true
};
try
{
await _cmContext.CocktailReviewLikes.AddAsync(cocktailReviewLikeNew);
await _cmContext.SaveChangesAsync();
var cocktailReviewLikeNewDTO = cocktailReviewLikeNew.CocktailReviewLikeMapToDTO();
return(cocktailReviewLikeNewDTO);
}
catch (Exception)
{
throw new InvalidOperationException("Cannot add into database!");
}
}
else
{
cocktailReviewLike.IsLiked = true;
await _cmContext.SaveChangesAsync();
}
var cocktailReviewLikeDTO = cocktailReviewLike.CocktailReviewLikeMapToDTO();
return(cocktailReviewLikeDTO);
}
public async Task AddIngredientAsync(IngredientDTO ingredient)
{
if (!CheckIfIngredientExist(ingredient.Name))
{
await _context.Ingredients.AddAsync(ingredient.ToEntity());
await _context.SaveChangesAsync();
}
else
{
throw new ArgumentException("Ingredient already exists!");
}
}
public async Task <IActionResult> Create([Bind("Id,BarId,UserId,Rating,Comment,DeletedOn,ReviewedOn")] BarReview barReview)
{
if (ModelState.IsValid)
{
barReview.Id = Guid.NewGuid();
_context.Add(barReview);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BarId"] = new SelectList(_context.Bars, "Id", "Address", barReview.BarId);
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", barReview.UserId);
return(View(barReview));
}
public async Task <IActionResult> Create(CqasUsuario cqasUsuario)
{
try
{
_context.CqasUsuario.Add(cqasUsuario);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View(cqasUsuario));
}
}
public async Task <CocktailDTO> CreateCocktail(CocktailDTO cocktailDTO)
{
if (cocktailDTO == null)
{
throw new ArgumentNullException("Cocktail doesn't exist!");
}
var cocktail = cocktailDTO.CocktailDTOMapToModel();
await _cmContext.Cocktails.AddAsync(cocktail);
await _cmContext.SaveChangesAsync();
return(cocktailDTO);
}
public async Task <IActionResult> Create(CqasMenu cqasMenu)
{
try
{
cqasMenu.Estado = 1;
_context.CqasMenu.Add(cqasMenu);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View(cqasMenu));
}
}
public async Task <IngredientDTO> CreateIngredient(IngredientDTO ingredientDTO)
{
if (ingredientDTO == null)
{
throw new ArgumentNullException("Ingredient doesn't exist!");
}
var ingredient = ingredientDTO.IngredientDTOMapToModel();
await _cmContext.Ingredients.AddAsync(ingredient);
await _cmContext.SaveChangesAsync();
return(ingredientDTO);
}
public async Task <BarReviewDTO> CreateBarReviewAsync(Guid barId, Guid userId, int rating, string comment)
{
var barReviewExists = await _cmContext.BarReviews.AnyAsync(br => br.UserId == userId && br.BarId == barId && br.DeletedOn == null);
if (barReviewExists)
{
throw new ArgumentException("This bar has already been reviewed by the user");
}
var bar = await _cmContext.Bars.Where(b => b.Id == barId && b.UnlistedOn == null).FirstOrDefaultAsync();
if (bar == null)
{
throw new ArgumentNullException("Bar is not available.");
}
var userExists = await _cmContext.Users.AnyAsync(u => u.Id == userId && u.DeletedOn == null);
if (!userExists)
{
throw new ArgumentNullException("User is not available");
}
if (rating < 1 || rating > 5)
{
throw new ArgumentOutOfRangeException("Rating must be bewtween 1 and 5.");
}
var barReview = new BarReview();
barReview.BarId = barId;
barReview.UserId = userId;
barReview.Rating = rating;
barReview.Comment = comment;
barReview.ReviewedOn = DateTime.UtcNow;
try
{
bar.AvgRating = await this.CalculateAvgRating(barId, rating);
_cmContext.BarReviews.Add(barReview);
await _cmContext.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
var barReviewDTO = barReview.BarMapReviewDTO();
return(barReviewDTO);
}
public async Task ExcludeDeletedCocktails_WhenCalled()
{
var options = TestUtils.GetOptions(nameof(ExcludeDeletedCocktails_WhenCalled));
using (var arrangeContext = new CMContext(options))
{
for (int i = 0; i < 4; i++)
{
arrangeContext.Add(new Cocktail());
}
;
arrangeContext.Add(new Cocktail()
{
DateDeleted = DateTime.Now
});
arrangeContext.Add(new Cocktail()
{
DateDeleted = DateTime.Now
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var result = await sut.GetPageCountForCocktials(2);
Assert.AreEqual(2, result);
}
}
public async Task CallNotificationManagerForEditNewCocktail_WithCorrectParameters()
{
var options = TestUtils.GetOptions(nameof(CallNotificationManagerForEditNewCocktail_WithCorrectParameters));
var adminName = "pesho";
var id = "1";
var oldName = "oldCocktail";
var cocktailName = "newCocktail";
var admin = new AppUser
{
Id = id,
UserName = adminName
};
_userServices.Setup(x => x.GetUsernameById(id))
.ReturnsAsync(admin.UserName);
_userServices.Setup(x => x.GetAdmin())
.ReturnsAsync(admin);
_iNotificationManager.Setup(x => x.CocktailEditedDescription(adminName, oldName, cocktailName))
.Returns($"LALALALA");
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(admin);
await arrangeContext.SaveChangesAsync();
var sut = new NotificationServices(arrangeContext, _userServices.Object,
_iNotificationManager.Object);
await sut.CocktailEditNotificationToAdminAsync(id, oldName, cocktailName);
_iNotificationManager.Verify(x => x.CocktailEditedDescription(adminName, oldName, cocktailName), Times.Once());
}
}
public async Task AddNotificationToDBForEditCocktailWithCorrectDecription_WithCorrectParameters()
{
var options = TestUtils.GetOptions(nameof(AddNotificationToDBForEditCocktailWithCorrectDecription_WithCorrectParameters));
var adminName = "pesho";
var id = "1";
var oldName = "oldCocktail";
var cocktailName = "newCocktail";
var admin = new AppUser
{
Id = id,
UserName = adminName
};
_userServices.Setup(x => x.GetUsernameById(id))
.ReturnsAsync(admin.UserName);
_userServices.Setup(x => x.GetAdmin())
.ReturnsAsync(admin);
_iNotificationManager.Setup(x => x.CocktailEditedDescription(adminName, oldName, cocktailName))
.Returns("LALALALALA");
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(admin);
await arrangeContext.SaveChangesAsync();
Assert.AreEqual(0, arrangeContext.Notifications.Count());
var sut = new NotificationServices(arrangeContext, _userServices.Object,
_iNotificationManager.Object);
await sut.CocktailEditNotificationToAdminAsync(id, oldName, cocktailName);
Assert.AreEqual("LALALALALA", arrangeContext.Notifications.First().Description);
Assert.AreEqual(adminName, arrangeContext.Notifications.First().Username);
}
}
public async Task CreateCocktail_Throws_When_NameExists()
{
//Arrange
var options = Utils.GetOptions(nameof(CreateCocktail_Throws_When_NameExists));
var cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "Cuba Libre"
};
var cocktailDTO = new CocktailDTO
{
Name = "Cuba Libre"
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.CreateCocktail(cocktailDTO));
}
}
public async Task ThrowCorrectMessage_WhenPassedBarIsNull()
{
var options = TestUtils.GetOptions(nameof(ThrowCorrectMessage_WhenPassedBarIsNull));
var user = new AppUser {
Id = "1"
};
var barReviewDTO = new BarReviewDTO
{
Rating = 10,
Description = "10",
UserID = "1",
BarId = "2"
};
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(user);
await arrangeContext.SaveChangesAsync();
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.CreateBarReview(barReviewDTO)
);
Assert.AreEqual(ExceptionMessages.BarNull, ex.Message);
}
}
public async Task SetsNewRating_WhenValidModelIsPassed()
{
var options = TestUtils.GetOptions(nameof(SetsNewRating_WhenValidModelIsPassed));
var user = new AppUser {
Id = "1"
};
var bar = new Bar {
Id = "2"
};
var barReviewDTO = new BarReviewDTO
{
Rating = 8,
Description = "10",
UserID = "1",
BarId = "2"
};
var review = new BarReview {
Rating = 10, Description = "0100101", BarId = "2"
};
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(user);
arrangeContext.Add(bar);
arrangeContext.Add(review);
await arrangeContext.SaveChangesAsync();
await sut.CreateBarReview(barReviewDTO);
Assert.AreEqual(9, arrangeContext.Bars.First().BarRating);
}
}
public async Task ThrowExceptionWithCorrectMessage_WhenUserAlreadyReviewedBar()
{
var options = TestUtils.GetOptions(nameof(ThrowExceptionWithCorrectMessage_WhenUserAlreadyReviewedBar));
var user = new AppUser {
Id = "1"
};
var bar = new Bar {
Id = "2"
};
var barReviewDTO = new BarReviewDTO
{
Rating = 10,
Description = "10",
UserID = "1",
BarId = "2"
};
var review = new BarReview {
Rating = 5, Description = "0100101", UserId = "1", BarId = "2"
};
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(user);
arrangeContext.Add(bar);
arrangeContext.Add(review);
await arrangeContext.SaveChangesAsync();
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.CreateBarReview(barReviewDTO)
);
Assert.AreEqual("You have already reviewed this bar!", ex.Message);
}
}
public async Task AddCorrectReviewToDB_WhenValidModelIsPassed()
{
var options = TestUtils.GetOptions(nameof(AddCorrectReviewToDB_WhenValidModelIsPassed));
var user = new AppUser {
Id = "1"
};
var bar = new Bar {
Id = "2"
};
var barReviewDTO = new BarReviewDTO
{
Rating = 10,
Description = "10",
UserID = "1",
BarId = "2"
};
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(user);
arrangeContext.Add(bar);
await arrangeContext.SaveChangesAsync();
await sut.CreateBarReview(barReviewDTO);
Assert.AreEqual(10, arrangeContext.BarReviews.First().Rating);
Assert.AreEqual("10", arrangeContext.BarReviews.First().Description);
Assert.AreEqual("1", arrangeContext.BarReviews.First().UserId);
Assert.AreEqual("2", arrangeContext.BarReviews.First().BarId);
}
}
public async Task <BarDTO> CreateBarAsync(BarDTO barDTO)
{
try
{
var bar = barDTO.BarDTOMapToModel();
await _cmContext.Bars.AddAsync(bar);
await _cmContext.SaveChangesAsync();
return(barDTO);
}
catch (Exception)
{
throw;
}
}
public async Task GetCityAsync_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(GetCityAsync_Correct));
var cityId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b");
var city = new City()
{
Id = cityId,
Name = "Varna"
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Cities.Add(city);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new CityService(assertContext);
var result = await sut.GetCityAsync(cityId);
Assert.AreEqual(cityId, result.Id);
Assert.IsInstanceOfType(result, typeof(CityDTO));
}
}
public async Task LikeCocktailReview_WhenValidBarIdIsPassed()
{
var options = TestUtils.GetOptions(nameof(LikeCocktailReview_WhenValidBarIdIsPassed));
var cocktail = new Cocktail {
Id = "2"
};
var user = new AppUser {
Id = "1"
};
var review1 = new CocktailReview {
Id = "1", Rating = 6, Description = "0100101", UserId = user.Id, CocktailId = "2"
};
var review2 = new CocktailReview {
Id = "2", Rating = 10, Description = "0100101", UserId = user.Id, CocktailId = "2"
};
//var like1 = new BarReviewLike { Id = "1", BarReviewID = "1" , AppUserID = "1"};
//var like2 = new BarReviewLike { Id = "2", BarReviewID = "2", AppUserID="1" };
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(cocktail);
arrangeContext.Add(user);
arrangeContext.Add(review1);
arrangeContext.Add(review2);
await arrangeContext.SaveChangesAsync();
await sut.LikeCocktailReview(cocktail.Id, user.Id);
Assert.AreEqual("1", arrangeContext.CocktailReviews.First().UserId);
Assert.AreEqual("2", arrangeContext.CocktailReviews.First().CocktailId);
}
}
