public void Add(AddReviewDto dto, string currentUserId)
{
UserManager.IsUserInRegularRole(currentUserId);
var user = UserManager.CheckAndGet(currentUserId);
var carService = UnitOfWork.Repository <ICarServiceRepository>().Get(dto.ServiceId);
if (carService == null)
{
throw new BusinessFaultException(BusinessLogicExceptionResources.CarServiceNotFound);
}
if (carService.Reviews.Any(rev => !rev.IsDeleted && rev.User.ApplicationUser.Id == currentUserId))
{
throw new BusinessFaultException(BusinessLogicExceptionResources.ReviewAlreadyContains);
}
var validationResult = _validationManager.ValidateOperateReviewDto(dto);
if (validationResult.HasErrors)
{
throw new BusinessFaultException(validationResult.GetErrors());
}
var review = Mapper.Map <CarServiceReview>(dto);
review.User = user.UserProfile;
review.Service = carService;
carService.Points += review.Mark;
review.Service.Reviews.Add(review);
UnitOfWork.SaveChanges();
}
public async Task TestAddReviewDto()
{
//SETUP
var options = SqliteInMemory.CreateOptions <BookDbContext>();
using var context = new BookDbContext(options);
context.Database.EnsureCreated();
var books = context.SeedDatabaseFourBooks();
context.ChangeTracker.Clear();
var utData = context.SetupSingleDtoAndEntities <AddReviewDto>();
var service = new CrudServicesAsync(context, utData.ConfigAndMapper);
//ATTEMPT
var dto = new AddReviewDto
{
BookId = books[0].BookId, NumStars = 5, Comment = "Great Book", VoterName = "Test"
};
await service.UpdateAndSaveAsync(dto);
//VERIFY
var book = context.Books.Include(x => x.Reviews).Single(x => x.BookId == books[0].BookId);
book.Reviews.Count.ShouldEqual(1);
book.Reviews.Single().NumStars.ShouldEqual(5);
book.Reviews.Single().Comment.ShouldEqual("Great Book");
book.Reviews.Single().VoterName.ShouldEqual("Test");
}
public IActionResult AddReview(AddReviewDto dto)
{
try
{
ValidateCaptcha();
using (var uow = _vendrApi.Uow.Create())
{
var review = new Review(dto.StoreId, dto.ProductReference, dto.CustomerReference)
{
Rating = dto.Rating,
Title = dto.Title,
Email = dto.Email,
Name = dto.Name,
Body = dto.Body,
RecommendProduct = dto.RecommendProduct
};
_reviewService.SaveReview(review);
uow.Complete();
}
}
catch (ValidationException ex)
{
ModelState.AddModelError("", "Failed to submit review: " + ex.Message);
return(CurrentUmbracoPage());
}
TempData["SuccessMessage"] = "Review successfully submitted";
return(RedirectToCurrentUmbracoPage());
}
public async Task <ServiceResponse <bool> > AddReviewToFlight(AddReviewDto review)
{
ServiceResponse <bool> serviceResponse = new ServiceResponse <bool>();
try
{
User dbUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == review.UserId);
Flight dbFlight = await _context.Flights.FirstOrDefaultAsync(f => f.Id == review.FlightId);
Review dbReview = new Review()
{
User = dbUser,
Flight = dbFlight,
Rating = review.Rating
};
await _context.Reviews.AddAsync(dbReview);
await _context.SaveChangesAsync();
serviceResponse.Data = true;
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public IActionResult AddReview(AddReviewDto dto, [FromServices] IAddReviewService service)
{
var book = service.AddReviewToBook(dto);
SetupTraceInfo();
return(View("BookUpdated", "Successfully added a review"));
}
public void OnGet(int id)
{
Data = _service.ReadSingle <AddReviewDto>(id);
if (!_service.IsValid)
{
_service.CopyErrorsToModelState(ModelState, Data, nameof(Data));
}
}
public Book AddReviewToBook(AddReviewDto dto)
{
var book = _context.Find <Book>(dto.BookId);
if (book == null)
{
throw new InvalidOperationException($"Could not find the book with Id of {dto.BookId}.");
}
book.AddReview(dto.NumStars, dto.Comment, dto.VoterName, _context);
_context.SaveChanges();
return(book);
}
public EditorViewModel(EditorListDto loggedEditor, UpdateManuscriptService updateManuscriptService,
AddReviewService addReviewService, ListFrontReviewerService listFrontReviewerService) : this(new EfCoreContext())
{
LoggedEditor = loggedEditor;
EditorFirstName = loggedEditor.Name.Split(' ').First() + "!";
InputOrderInIssue = "";
InputTotalPagesOccupied = "";
InputBeginningPageNumber = "";
_updateManuscriptService = updateManuscriptService;
_addReviewService = addReviewService;
_listFrontReviewerService = listFrontReviewerService;
FrontReviewerList = GetReviewerSelectionList();
ManuscriptToUpdate = new ManuscriptListDto();
ReviewToAdd = new AddReviewDto();
_manuscriptService = new ListManuscriptService(_context);
_issueService = new ListIssueService(_context);
_reviewService = new ListReviewService(_context);
var manuscripts = _manuscriptService.GetManuscriptList().ToList();
var issues = _issueService.GetIssueList().ToList();
var reviews = _reviewService.GetReviewList().ToList();
ManuscriptList = new ObservableCollection <ManuscriptListDto>(manuscripts);
IssueList = new ObservableCollection <IssueListDto>(issues);
ReviewList = new ObservableCollection <ReviewListDto>(reviews);
foreach (var manuscript in ManuscriptList)
{
if (manuscript.ManuscriptStatus == 1)
{
ReceivedManuscriptList.Add(manuscript);
}
if (manuscript.ManuscriptStatus == 3)
{
foreach (var review in ReviewList)
{
if (review.ManuscriptId == manuscript.ManuscriptId && review.AppropriatenessScore != 0 && UnderReviewManuscriptList.Contains(manuscript) != true)
{
UnderReviewManuscriptList.Add(manuscript);
}
}
}
if (manuscript.ManuscriptStatus == 4)
{
AcceptedManuscriptList.Add(manuscript);
}
}
}
public Book AddReviewToBook(AddReviewDto dto)
{
var book = _context.Find <Book>(dto.BookId);
if (book == null)
{
AddError("Sorry, I could not find the book you were looking for.");
return(null);
}
book.AddReview(dto.NumStars, dto.Comment, dto.VoterName, _context);
_context.SaveChanges();
return(book);
}
public async Task TestDeleteReviewOk()
{
//SETUP
var options = SqliteInMemory.CreateOptions <ExampleDbContext>();
using (var context = new ExampleDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDatabase();
var controller = new BookController();
var utData = context.SetupSingleDtoAndEntities <AddReviewDto>(_genericServiceConfig);
var service = new CrudServicesAsync(context, utData.ConfigAndMapper);
//ATTEMPT
var dto = new AddReviewDto()
{
BookId = 1,
Title = "Efcore in action",
VoterName = "test",
NumStars = 5,
Comment = "test comment",
};
var response = await controller.AddReview(dto, service);
//VERIFY
response.GetStatusCode().ShouldEqual(200);
//Delete review
utData = context.SetupSingleDtoAndEntities <RemoveReviewDto>(_genericServiceConfig);
service = new CrudServicesAsync(context, utData.ConfigAndMapper);
//ATTEMPT
var removeReviewDto = new RemoveReviewDto()
{
BookId = 1,
ReviewId = 1
};
response = await controller.DeleteReview(removeReviewDto, service);
//VERIFY
response.GetStatusCode().ShouldEqual(200);
}
}
public IActionResult AddBookReview(AddReviewDto dto, [FromServices] ICrudServices service)
{
if (!ModelState.IsValid)
{
return(View(dto));
}
service.UpdateAndSave(dto);
SetupTraceInfo();
if (service.IsValid)
{
return(View("BookUpdated", service.Message));
}
//Error state
service.CopyErrorsToModelState(ModelState, dto);
return(View(dto));
}
public async Task <IActionResult> AddBookReview(AddReviewDto dto, [FromServices] ICrudServicesAsync <BookDbContext> service)
{
Request.ThrowErrorIfNotLocal();
if (!ModelState.IsValid)
{
return(View(dto));
}
await service.UpdateAndSaveAsync(dto);
SetupTraceInfo();
if (service.IsValid)
{
return(View("BookUpdated", new BookUpdatedDto(service.Message, _backToDisplayController)));
}
//Error state
service.CopyErrorsToModelState(ModelState, dto);
return(View(dto));
}
public void RunGenericService()
{
//SETUP
using (var context = new EfCoreContext(_options))
{
var service = new CrudServices <EfCoreContext>(context, _utData.ConfigAndMapper);
var numReviews = context.Set <Review>().Count();
//ATTEMPT
var dto = new AddReviewDto {
BookId = 1, Comment = "comment", NumStars = 3, VoterName = "user"
};
service.UpdateAndSave(dto, nameof(Book.AddReview));
//VERIFY
service.IsValid.ShouldBeTrue(service.GetAllErrors());
context.Set <Review>().Count().ShouldEqual(numReviews + 1);
}
}
public ActionResult Add(AddReviewDto addReviewDto)
{
if (User.IsInRole("Doctor"))
{
return(BadRequest("Nu aveti dreptul de a adauga review-uri!"));
}
var userPacientId = User.GetUserId();
var pacientId = _context.Pacients.FirstOrDefault(c => c.UserId == userPacientId).Id;
addReviewDto.PacientId = pacientId;
if (_reviewRepository.AddReview(addReviewDto))
{
return(Ok());
}
return(BadRequest("Nu am putut adauga review-ul!"));
}
public bool AddReview(AddReviewDto addReviewDto)
{
var newReview = new Review
{
PacientId = (int)addReviewDto.PacientId,
DoctorId = addReviewDto.DoctorId,
Rating = addReviewDto.Rating,
Content = addReviewDto.Content,
DateAdded = DateTime.UtcNow
};
_context.Reviews.Add(newReview);
if (_context.SaveChanges() > 0)
{
return(true);
}
return(false);
}
public async Task <ActionResult <ReviewDto> > ReviewAsync(AddReviewDto inputModel)
{
var user = await userManager.GetUserAsync(User);
var review = new Review
{
UserId = user.Id,
BookId = inputModel.BookId,
Text = inputModel.Review
};
dbContext.Reviews.Add(review);
await dbContext.SaveChangesAsync();
return(new ReviewDto
{
Id = review.Id,
Text = review.Text,
Author = user.UserName,
DateTime = review.DateTime
});
}
public async Task <ActionResult <WebApiMessageOnly> > AddReview(AddReviewDto item, [FromServices] ICrudServicesAsync service)
{
await service.UpdateAndSaveAsync(item, nameof(Book.AddReview));
return(service.Response());
}
public IHttpActionResult Add(AddReviewDto dto)
{
return(CallBusinessLogicAction(() => _manager.Add(dto, User.Identity.GetUserId())));
}
public async Task <IActionResult> AddReview(AddReviewDto review)
{
return(Ok(await _flightService.AddReviewToFlight(review)));
}
public ActionResult <WebApiMessageOnly> AddReview2(
AddReviewDto dto, [FromServices] ICrudServices service)
{
service.UpdateAndSave(dto);
return(service.Response());
}
