public async Task <CocktailReviewDTO> CreateCocktailReviewAsync(CocktailReviewDTO cocktailReviewDTO)
{
if (cocktailReviewDTO == null)
{
return(null);
}
;
var cocktailReview = this.cocktailReviewMapper.MapToCocktailReview(cocktailReviewDTO);
cocktailReview.CreatedOn = this.dateTimeProvider.GetDateTime();
this.context.CocktailsUsersReviews.Add(cocktailReview);
await this.context.SaveChangesAsync();
var cocktail = await this.context.Cocktails.FirstOrDefaultAsync(c => c.Id == cocktailReview.CocktailId);
cocktail.AverageRating = GetCocktailRating(cocktail.Id);
this.context.Cocktails.Update(cocktail);
await this.context.SaveChangesAsync();
var newCocktailReviewDTO = await this.GetCocktailReviewAsync(cocktailReview.CocktailId, cocktailReview.UserId);
return(newCocktailReviewDTO);
}
public bool CocktailReviewIsUnique(CocktailReviewDTO cocktailReviewDTO)
{
if (this.context.CocktailsUsersReviews
.Any(x => x.UserId.Equals(cocktailReviewDTO.AuthorId) &&
x.CocktailId.Equals(cocktailReviewDTO.CocktailId)))
{
return(false);
}
return(true);
}
public CocktailReviewDTO MapToDTOFromVM(CreateCocktailReviewViewModel createCocktailReviewVM)
{
var reviewDTO = new CocktailReviewDTO
{
Comment = createCocktailReviewVM.Comment,
CocktailId = createCocktailReviewVM.CocktailId,
AuthorId = createCocktailReviewVM.AuthorId,
Rating = createCocktailReviewVM.Rating
};
return(reviewDTO);
}
public CocktailsUsersReviews MapToCocktailReview(CocktailReviewDTO reviewDTO)
{
CocktailsUsersReviews review = new CocktailsUsersReviews
{
Rating = reviewDTO.Rating,
Comment = reviewDTO.Comment,
CocktailId = reviewDTO.CocktailId,
UserId = reviewDTO.AuthorId
};
return(review);
}
public static CocktailReview ToEntity(this CocktailReviewDTO cocktailReviewDTO)
{
var cocktailReview = new CocktailReview
{
UserId = cocktailReviewDTO.UserId,
CocktailId = cocktailReviewDTO.CocktailId,
Grade = cocktailReviewDTO.Grade,
Comment = cocktailReviewDTO.Comment,
CreatedOn = cocktailReviewDTO.CreatedOn
};
return(cocktailReview);
}
public static CocktailReviewDTO ToCocktailDTO(this CreateReviewViewModel createReviewViewModel)
{
var cocktailCommentDTO = new CocktailReviewDTO
{
CocktailId = createReviewViewModel.Id,
UserId = createReviewViewModel.UserId,
Comment = createReviewViewModel.Comment,
Grade = createReviewViewModel.Rate,
CreatedOn = createReviewViewModel.DateCreated
};
return(cocktailCommentDTO);
}
public static CocktailReviewViewModel CocktailReviewsDTOMapToVM(this CocktailReviewDTO cocktailReviewDTO)
{
var cocktailReview = new CocktailReviewViewModel();
cocktailReview.Id = cocktailReviewDTO.Id;
cocktailReview.Rating = cocktailReviewDTO.Rating;
cocktailReview.Comment = cocktailReviewDTO.Comment;
cocktailReview.CocktailId = cocktailReviewDTO.CocktailId;
cocktailReview.UserId = cocktailReviewDTO.UserId;
cocktailReview.UserName = cocktailReviewDTO.UserName;
cocktailReview.ReviewedOn = cocktailReviewDTO.ReviewedOn;
return(cocktailReview);
}
public CocktailReviewViewModel MapToVMFromDTO(CocktailReviewDTO cocktailReviewDTO)
{
var reviewVM = new CocktailReviewViewModel
{
Rating = cocktailReviewDTO.Rating,
Comment = cocktailReviewDTO.Comment,
CocktailId = cocktailReviewDTO.CocktailId,
AuthorId = cocktailReviewDTO.AuthorId,
CocktailName = cocktailReviewDTO.CocktailName,
Author = cocktailReviewDTO.Author
};
return(reviewVM);
}
public CocktailReviewDTO MapToCocktailReviewDTO(CocktailsUsersReviews review)
{
CocktailReviewDTO reviewDTO = new CocktailReviewDTO
{
Rating = review.Rating,
Comment = review.Comment,
CocktailId = review.CocktailId,
CocktailName = review.Cocktail.Name,
AuthorId = review.UserId,
Author = review.User.UserName
};
return(reviewDTO);
}
public static CocktailReviewDTO ToCocktailReviewDTO(this ReviewViewModel cocktailReviewView)
{
var vm = new CocktailReviewDTO
{
CocktailId = cocktailReviewView.Id,
UserId = cocktailReviewView.UserId,
Grade = cocktailReviewView.Grade,
Comment = cocktailReviewView.Comment,
UserName = cocktailReviewView.UserName,
UserPicture = cocktailReviewView.UserPicture,
CreatedOn = cocktailReviewView.CreatedOn
};
return(vm);
}
public static ReviewViewModel ToCocktailReviewVM(this CocktailReviewDTO cocktailReviewDTO)
{
var vm = new ReviewViewModel
{
Id = cocktailReviewDTO.CocktailId,
UserId = cocktailReviewDTO.UserId,
Grade = cocktailReviewDTO.Grade,
Comment = cocktailReviewDTO.Comment,
UserName = cocktailReviewDTO.UserName,
UserPicture = cocktailReviewDTO.UserPicture,
CreatedOn = cocktailReviewDTO.CreatedOn
};
return(vm);
}
public void Return_CocktailVM()
{
var cocktailReviewDTO = new CocktailReviewDTO()
{
Id = Guid.Parse("9ef97551-87f6-40ce-a88b-6c0e876ccb51"),
CocktailId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"),
UserId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"),
Rating = 4,
Comment = "Nice"
};
var result = cocktailReviewDTO.CocktailReviewsDTOMapToVM();
Assert.IsInstanceOfType(result, typeof(CocktailReviewViewModel));
}
public static CocktailReviewDTO ToDTO(this CocktailReview cocktailReview)
{
var cocktailReviewDTO = new CocktailReviewDTO
{
UserId = cocktailReview.UserId,
CocktailId = cocktailReview.CocktailId,
Grade = cocktailReview.Grade,
Comment = cocktailReview.Comment,
UserName = cocktailReview.User.UserName,
UserPicture = cocktailReview.User.Picture,
CreatedOn = cocktailReview.CreatedOn
};
return(cocktailReviewDTO);
}
public static CocktailReviewDTO MapReviewToDTO(this CocktailReview review)
{
var newReviewDTO = new CocktailReviewDTO();
newReviewDTO.Id = review.Id;
newReviewDTO.CocktailID = review.CocktailId;
newReviewDTO.Description = review.Description;
newReviewDTO.UserName = review.User.UserName;
newReviewDTO.UserID = review.UserId;
newReviewDTO.ReviewDate = review.ReviewDate;
newReviewDTO.Rating = review.Rating;
newReviewDTO.LikeCount = review.CocktailReviewLikes.Count;
newReviewDTO.LikedByUsers = review.CocktailReviewLikes.Select(b => b.AppUserID).ToList();
return(newReviewDTO);
}
public static CocktailReviewViewModel MapToViewModel(this CocktailReviewDTO reviewDTO)
{
var reviewVm = new CocktailReviewViewModel();
reviewVm.Id = reviewDTO.Id;
reviewVm.CocktailID = reviewDTO.CocktailID;
reviewVm.Description = reviewDTO.Description;
reviewVm.LikeCount = reviewDTO.LikeCount;
reviewVm.LikedByUsers = reviewDTO.LikedByUsers;
reviewVm.Rating = reviewDTO.Rating;
reviewVm.UserName = reviewDTO.UserName;
reviewVm.ReviewDate = reviewDTO.ReviewDate;
reviewVm.UserId = reviewDTO.UserID;
reviewVm.ReviewDate = reviewDTO.ReviewDate;
return(reviewVm);
}
/// <summary>
/// This method checks if the User with the given Id has already reviewed the Bar
/// with the given Id.
/// </summary>
/// <param name="cocktailReviewDTO">CocktailReviewDTO object with the needed data for the review</param>
/// <returns>Task</returns>
public async Task CreateCocktailReviewAsync(CocktailReviewDTO cocktailReviewDTO)
{
if (cocktailReviewDTO.Grade > 0)
{
var cocktailReview = _cocktailFactory.CreateNewCocktailReview(cocktailReviewDTO.Grade, cocktailReviewDTO.Comment, cocktailReviewDTO.UserId, cocktailReviewDTO.CocktailId, cocktailReviewDTO.CreatedOn);
await _context.CocktailReviews.AddAsync(cocktailReview);
await _context.SaveChangesAsync();
await UpdateRating(cocktailReviewDTO.CocktailId);
}
else
{
await _context.SaveChangesAsync();
}
}
public static CocktailReviewDTO CocktailMapReviewDTO(this CocktailReview cocktailReview)
{
var cocktailReviewDTO = new CocktailReviewDTO();
cocktailReviewDTO.Id = cocktailReview.Id;
cocktailReviewDTO.CocktailId = cocktailReview.CocktailId;
cocktailReviewDTO.UserId = cocktailReview.UserId;
cocktailReviewDTO.Rating = cocktailReview.Rating;
cocktailReviewDTO.Comment = cocktailReview.Comment;
cocktailReviewDTO.ReviewedOn = cocktailReview.ReviewedOn;
cocktailReviewDTO.CocktailName = cocktailReview.Cocktail.Name;
cocktailReviewDTO.UserName = cocktailReview.User.UserName;
cocktailReviewDTO.CocktailReviewLikes = cocktailReview.CocktailReviewLikes;
return(cocktailReviewDTO);
}
public async Task ReturnUpdatedCReview_IfParamsAreValid()
{
//Arrange
var mockIDateTimeProvider = new Mock <IDateTimeProvider>();
var mockICocktailReviewMapper = new Mock <ICocktailReviewMapper>();
mockICocktailReviewMapper
.Setup(r => r.MapToCocktailReview(It.IsAny <CocktailReviewDTO>()))
.Returns <CocktailReviewDTO>(r => new CocktailsUsersReviews
{
CocktailId = r.CocktailId, UserId = r.AuthorId, Comment = r.Comment, Rating = r.Rating
});
mockICocktailReviewMapper
.Setup(r => r.MapToCocktailReviewDTO(It.IsAny <CocktailsUsersReviews>()))
.Returns <CocktailsUsersReviews>(r => new CocktailReviewDTO
{
CocktailId = r.CocktailId, AuthorId = r.UserId, Comment = r.Comment, Rating = r.Rating
});
var options = Utils.GetOptions(nameof(ReturnUpdatedCReview_IfParamsAreValid));
var updatedReview = new CocktailReviewDTO
{
CocktailId = 1,
AuthorId = 2,
Comment = "Worst!",
Rating = 1
};
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new CocktailReviewService(mockIDateTimeProvider.Object, assertContext, mockICocktailReviewMapper.Object);
var result = await sut.UpdateCocktailReviewAsync(1, 2, updatedReview);
Assert.AreEqual("Worst!", result.Comment);
Assert.AreEqual(1, result.Rating);
Assert.AreEqual(2, result.AuthorId);
Assert.AreEqual(1, result.CocktailId);
}
}
public ValidationModel ValidateCocktailReview(CocktailReviewDTO cocktailReviewDTO)
{
var validationModel = new ValidationModel();
if (cocktailReviewDTO == null)
{
validationModel.HasProperInputData = false;
}
if (cocktailReviewDTO.Rating < 1 || cocktailReviewDTO.Rating > 5)
{
validationModel.HasCorrectRating = false;
}
if (cocktailReviewDTO.Comment.Length > 500)
{
validationModel.HasCorrectCommentLength = false;
}
return(validationModel);
}
public async Task ReturnCocktailReview_IfParamsAreValid()
{
//Arrange
var mockIDateTimeProvider = new Mock <IDateTimeProvider>();
var mockICocktailReviewMapper = new Mock <ICocktailReviewMapper>();
mockICocktailReviewMapper
.Setup(r => r.MapToCocktailReview(It.IsAny <CocktailReviewDTO>()))
.Returns <CocktailReviewDTO>(r => new CocktailsUsersReviews
{
CocktailId = r.CocktailId, UserId = r.AuthorId, Comment = r.Comment
});
mockICocktailReviewMapper
.Setup(r => r.MapToCocktailReviewDTO(It.IsAny <CocktailsUsersReviews>()))
.Returns <CocktailsUsersReviews>(r => new CocktailReviewDTO
{
CocktailId = r.CocktailId, AuthorId = r.UserId, Comment = r.Comment
});
var options = Utils.GetOptions(nameof(ReturnCocktailReview_IfParamsAreValid));
var reviewDTO = new CocktailReviewDTO
{
CocktailId = 3,
AuthorId = 2,
Comment = "Bozdugan is for tough man!"
};
Utils.GetInMemoryDataBase(options);
//Act & Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new CocktailReviewService(mockIDateTimeProvider.Object, assertContext, mockICocktailReviewMapper.Object);
var result = await sut.CreateCocktailReviewAsync(reviewDTO);
Assert.AreEqual(5, assertContext.CocktailsUsersReviews.Count());
Assert.AreEqual(2, result.AuthorId);
Assert.AreEqual(3, result.CocktailId);
}
}
public void CorrectReturnInstanceType_ToCocktailReview()
{
//Arrange
var sut = new CocktailReviewMapper();
var options = Utils.GetOptions(nameof(CorrectReturnInstanceType_ToCocktailReview));
var reviewDTO = new CocktailReviewDTO
{
CocktailId = 1,
AuthorId = 2,
Comment = "Top!",
Rating = 4,
};
//Act
var result = sut.MapToCocktailReview(reviewDTO);
//Assert
Assert.IsInstanceOfType(result, typeof(CocktailsUsersReviews));
}
public async Task CreateCocktailReview()
{
var options = TestUtilities.GetOptions(nameof(CreateCocktailReview));
var mockIngredient = new Mock <IIngredientManager>();
var mockFactory = new Mock <ICocktailFactory>();
var mockCocktailReviewDTO = new CocktailReviewDTO()
{
CocktailId = "1",
Comment = "comment",
CreatedOn = DateTime.Now,
Grade = 4,
UserId = "1",
UserName = "******",
UserPicture = "UserPicture"
};
var cocktail = new Cocktail()
{
Id = "1", Information = "infomation", Rating = 1
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailManager(mockIngredient.Object, assertContext, mockFactory.Object);
await sut.CreateCocktailReviewAsync(mockCocktailReviewDTO);
Assert.AreEqual(1, assertContext.CocktailReviews.Count());
}
}
public void CorrectMapping_ToCocktailReview()
{
//Arrange
var sut = new CocktailReviewMapper();
var options = Utils.GetOptions(nameof(CorrectMapping_ToCocktailReview));
var reviewDTO = new CocktailReviewDTO
{
CocktailId = 1,
AuthorId = 2,
Comment = "Top!",
Rating = 4,
};
//Act
var result = sut.MapToCocktailReview(reviewDTO);
//Assert
Assert.AreEqual(reviewDTO.CocktailId, result.Cocktail);
Assert.AreEqual(reviewDTO.AuthorId, result.UserId);
Assert.AreEqual(reviewDTO.Comment, result.Comment);
Assert.AreEqual(reviewDTO.Rating, result.Rating);
}
public async Task <CocktailReviewDTO> UpdateCocktailReviewAsync(int cocktailId, int userId, CocktailReviewDTO cocktailReviewDTO)
{
if (cocktailReviewDTO == null)
{
return(null);
}
;
var cocktailReview = await this.context.CocktailsUsersReviews
.FirstOrDefaultAsync(r => r.CocktailId == cocktailId &&
r.UserId == userId &&
!r.IsDeleted);
if (cocktailReview == null)
{
return(null);
}
cocktailReview.Comment = cocktailReviewDTO.Comment;
cocktailReview.Rating = cocktailReviewDTO.Rating;
this.context.CocktailsUsersReviews.Update(cocktailReview);
await this.context.SaveChangesAsync();
var cocktail = await this.context.Cocktails.FirstOrDefaultAsync(c => c.Id == cocktailReview.CocktailId);
cocktail.AverageRating = GetCocktailRating(cocktail.Id);
this.context.Cocktails.Update(cocktail);
await this.context.SaveChangesAsync();
var newCocktailReviewDTO = await this.GetCocktailReviewAsync(cocktailId, userId);
return(newCocktailReviewDTO);
}