public async Task AddingSuccessfullyReviewShouldReturnTrue()
{
var user = new ApplicationUser()
{
Email = "*****@*****.**"
};
await this.UsersRepository.AddAsync(user);
var doctor = new Doctor()
{
Name = "Test",
User = user,
UserId = user.Id,
};
await this.DoctorsService.CreateDoctorAsync(user.Id, doctor);
var model = new AddReviewInputModel()
{
DoctorId = doctor.Id,
DoctorAttitudeReview = 3,
OverallReview = 3,
WaitingTimeReview = 3,
ReviewText = "Test",
};
var isAdded = await this.DoctorsService.AddReview(model);
Assert.True(isAdded);
}
public async Task <ReviewViewModel> AddAsync(AddReviewInputModel inputModel)
{
var review = new Review
{
ApplicationUserId = inputModel.ApplicationUserId,
MovieId = inputModel.MovieId,
Title = inputModel.Title,
Content = inputModel.Content,
Stars = inputModel.Stars,
};
await this.reviewsRepository.AddAsync(review);
await this.reviewsRepository.SaveChangesAsync();
var viewModel = new ReviewViewModel
{
Id = review.Id,
Title = review.Title,
Content = review.Content,
Stars = review.Stars,
CreatedOn = review.CreatedOn,
};
return(viewModel);
}
public async Task CreateAsync(AddReviewInputModel model, string imagePath, string userId)
{
var review = new Review()
{
Title = model.Title,
Description = model.Description,
VideoUrl = model.VideoUrl,
};
Directory.CreateDirectory($"{imagePath}/reviews/");
foreach (var image in model.Images)
{
var extension = Path.GetExtension(image.FileName).TrimStart('.');
var img = new Image()
{
AddedByUserId = userId,
Extension = extension,
};
review.Images.Add(img);
var path = $"{imagePath}/reviews/{img.Id}.{extension}";
using Stream fileStream = new FileStream(path, FileMode.Create);
await image.CopyToAsync(fileStream);
}
await this.reviewsRepository.AddAsync(review);
await this.reviewsRepository.SaveChangesAsync();
}
public async Task GetAllByMovieIdShouldWorkCorrectly()
{
var context = new ApplicationDbContext(this.options.Options);
var repository = new EfDeletableEntityRepository <Review>(context);
var service = this.GetReviewsService(repository);
var diffReview = new AddReviewInputModel
{
ApplicationUserId = "me",
MovieId = 2,
Title = "title",
Content = "content",
Stars = 3,
};
await service.AddAsync(diffReview);
await service.AddAsync(this.review);
await service.AddAsync(this.review);
var result = service.GetAllByMovieId <TestReviewViewModel>(1);
Assert.Equal(2, result.Count());
}
public async Task <ReviewViewModel> EditAsync(AddReviewInputModel inputModel)
{
var review = await this.reviewsRepository.GetByIdWithDeletedAsync(inputModel.Id);
if (review == null)
{
throw new ArgumentNullException(InvalidIdExceptionMessage);
}
review.Title = inputModel.Title;
review.Content = inputModel.Content;
this.reviewsRepository.Update(review);
await this.reviewsRepository.SaveChangesAsync();
var viewModel = new ReviewViewModel
{
Id = review.Id,
Title = review.Title,
Content = review.Content,
CreatedOn = review.CreatedOn,
Stars = review.Stars,
};
return(viewModel);
}
public async Task <ActionResult <ReviewViewModel> > Edit(AddReviewInputModel inputModel)
{
var user = await this.userManager.GetUserAsync(this.User);
var viewModel = await this.reviewsService.EditAsync(inputModel);
viewModel.ApplicationUserUserName = user.UserName;
return(viewModel);
}
public async Task <IActionResult> Add(AddReviewInputModel model)
{
var userId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
model.UserId = userId;
await this.reviewService.AddAsync(model);
return(this.RedirectToAction("Details", "Games", new { id = model.GameId, success = "true" }));
}
public async Task <IActionResult> Add(string dessertId, string orderId)
{
var model = new AddReviewInputModel()
{
Dessert = await this.dessertsService.GetDetailsAsync <DessertAddReviewViewModel>(dessertId),
OrderId = orderId,
};
return(this.View(model));
}
public IActionResult AddReview(string doctorId, string consultationId)
{
var viewModel = new AddReviewInputModel()
{
ConsultationId = consultationId,
DoctorId = doctorId,
DoctorName = this.doctorsService.GetDoctorNameById(doctorId),
};
return(this.View(viewModel));
}
public async Task <IActionResult> AddReview(AddReviewInputModel model)
{
if (this.doctorsService.AddReview(model).Result)
{
await this.consultationsService.MakeConsultationReviewedToTrue(model.ConsultationId);
return(this.RedirectToAction(nameof(this.Info), new { id = model.DoctorId }));
}
return(this.View(model));
}
public async Task <IActionResult> Create(AddReviewInputModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(inputModel));
}
var userId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var imagePath = this.environment.WebRootPath;
await this.reviewService.CreateAsync(inputModel, imagePath, userId);
return(this.RedirectToAction("Index"));
}
public ReviewsServiceTests()
{
this.review = new AddReviewInputModel
{
ApplicationUserId = "userId",
MovieId = 1,
Title = "Cool!",
Content = "Nice!",
Stars = 4,
};
AutoMapperConfig.RegisterMappings(typeof(TestReviewViewModel).Assembly);
this.options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
}
public async Task <IActionResult> Add(AddReviewInputModel input)
{
if (!this.ModelState.IsValid)
{
input.Dessert = await this.dessertsService.GetDetailsAsync <DessertAddReviewViewModel>(input.Dessert.Id);
return(this.View(input));
}
var userId = this.userManager.GetUserId(this.User);
await this.reviewsService.AddAsync(input.Content, input.Points, input.OrderId, input.Dessert.Id, userId);
this.TempData["InfoMessage"] = GlobalConstants.SuccessAddedMessage;
return(this.Redirect($"/Orders/GetOrderDetails/{input.OrderId}"));
}
public async Task <IActionResult> Add(AddReviewInputModel model)
{
if (!ModelState.IsValid)
{
return(this.BadRequest("Invalid input data."));
}
await this.reviewService
.Create(model.Title,
model.Description,
model.AuthorId,
model.Author,
model.BookId,
model.BookName);
return(Ok());
}
public async Task <bool> AddReview(AddReviewInputModel model)
{
var doctor = this.GetDoctorById(model.DoctorId);
var review = new Review()
{
DoctorAttitudeReview = model.DoctorAttitudeReview,
OverallReview = model.OverallReview,
WaitingTimeReview = model.WaitingTimeReview,
ReviewText = model.ReviewText,
};
doctor.Reviews.Add(review);
await this.doctorsRepository.SaveChangesAsync();
return(true);
}
public async Task AddReview(AddReviewInputModel inputModel)
{
var curretnUser = await this.db.Users.FirstOrDefaultAsync(x => x.UserName == inputModel.Username);
var review = new ProductReview
{
ApplicationUserId = curretnUser?.Id,
Email = inputModel.Email,
PhoneNumber = inputModel.PhoneNumber,
ProductId = inputModel.ProductId,
CreatedOn = DateTime.UtcNow,
UserFullName = inputModel.FullName,
Content = inputModel.SanitizedContent,
Stars = inputModel.Stars,
};
await this.db.ProductReviews.AddAsync(review);
await this.db.SaveChangesAsync();
}
public async Task EditReviewShouldWorkCorrectly()
{
var context = new ApplicationDbContext(this.options.Options);
var repository = new EfDeletableEntityRepository <Review>(context);
var service = this.GetReviewsService(repository);
var diffReview = new AddReviewInputModel
{
Id = 1,
Title = "title",
Content = "content",
};
var added = await service.AddAsync(this.review);
var result = await service.EditAsync(diffReview);
Assert.Equal("title", result.Title);
Assert.Equal("content", result.Content);
}
public async Task AddAsync(AddReviewInputModel model)
{
var review = await this.reviewRepository.All()
.FirstOrDefaultAsync(x => x.GameId == model.GameId && x.UserId == model.UserId);
if (review == null)
{
var ratingId = this.ratingRepository.AllAsNoTracking()
.FirstOrDefault(x => x.GameId == model.GameId && x.UserId == model.UserId).Id;
review = new Review
{
GameId = model.GameId,
UserId = model.UserId,
RatingId = ratingId,
};
await this.reviewRepository.AddAsync(review);
}
review.Text = model.Text;
await this.reviewRepository.SaveChangesAsync();
}
public async Task GetAllByMovieIdShouldReturnEmptyListWithInvalidMovieId()
{
var context = new ApplicationDbContext(this.options.Options);
var repository = new EfDeletableEntityRepository <Review>(context);
var service = this.GetReviewsService(repository);
var diffReview = new AddReviewInputModel
{
ApplicationUserId = "me",
MovieId = 2,
Title = "title",
Content = "content",
Stars = 3,
};
await service.AddAsync(diffReview);
await service.AddAsync(this.review);
var result = service.GetAllByMovieId <TestReviewViewModel>(3);
Assert.Empty(result);
}
// GET: Administration/Reviews/Create
public IActionResult Create()
{
var inputModel = new AddReviewInputModel();
return(this.View(inputModel));
}
