public async Task <IActionResult> EditReview([FromBody] ReviewForCreationDto reviewForCreationDto, int reviewId) { if (reviewForCreationDto.UserId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } // make sure logged in user is the creator of the review Review review = await _context.Reviews.FirstOrDefaultAsync(x => x.Id == reviewId); var previousScore = review.StarScore; review.LocationId = reviewForCreationDto.LocationId; review.Text = reviewForCreationDto.Text; review.StarScore = reviewForCreationDto.Star; Product product = await _context.Products.FirstOrDefaultAsync(x => x.Id == reviewForCreationDto.ProductId); product.StarRating = ((product.StarRating * 2) * (product.ReviewCount - 1) + (product.StarRating * 2 + (review.StarScore - previousScore))) / (2 * product.ReviewCount); // product.StarRating = ((product.StarRating * 2) * (product.ReviewCount - 1) + (review.StarScore)) / (2 * product.ReviewCount); if (await _context.SaveChangesAsync() > 0) { return(Ok(review)); } return(BadRequest("something went wrong")); }
public IActionResult CreateReview([FromBody] ReviewForCreationDto review) { try { if (review == null) { _logger.LogError("Review object sent from client is null."); return(BadRequest("Review object is null")); } if (!ModelState.IsValid) { _logger.LogError("Invalid Review object sent from client."); return(BadRequest("Invalid model object")); } bool succes = _reviewLogic.Create(review); return(Ok(true)); } catch (Exception ex) { return(StatusCode(500, "Internal server error")); } }
public async Task <IActionResult> CreateReview(int userId, ReviewForCreationDto ReviewForCreationDto) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } ReviewForCreationDto.SenderId = userId; var hotelRecipient = await _repo.GetHotel(ReviewForCreationDto.RecipientId); if (hotelRecipient == null) { return(BadRequest("Could not find this hotel")); } var review = _mapper.Map <Review>(ReviewForCreationDto); _repo.Add(review); var reviewToReturn = _mapper.Map <ReviewForCreationDto>(review); if (await _repo.SaveAll()) { return(CreatedAtRoute("GetReview", new { id = review.Id }, reviewToReturn)); } throw new Exception("Creating the review failed on save"); }
public async Task <IActionResult> AddReview([FromBody] ReviewForCreationDto reviewForCreationDto) { // try with photo // consider deleting reviews and adding reviewCount to user var reviewed = await _context.Reviews .FirstOrDefaultAsync(x => x.UserId == reviewForCreationDto.UserId && x.ProductId == reviewForCreationDto.ProductId); if (reviewed != null) { return(BadRequest("User has already reviewed this product")); } var review = reviewForCreationDto.Adapt <Review>(); var product = await _context.Products.FirstOrDefaultAsync(x => x.Id == reviewForCreationDto.ProductId); var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == reviewForCreationDto.UserId); product.StarRating = ((product.StarRating * 2) * product.ReviewCount + reviewForCreationDto.Star) / (2 * (product.ReviewCount + 1)); product.ReviewCount++; user.ReviewCount++; _context.Add(review); _context.SaveChanges(); return(Ok(review)); }
public async Task <IActionResult> AddReviewsByDate(ReviewForCreationDto dto) { int reviewerId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); List <Review> reviewsToAdd = new List <Review>(); int count = 0; try { var reviewsFromWeb = GetReviewsFromWeb(dto, reviewerId); reviewsFromWeb = reviewsFromWeb.Where(rev => rev.ReviewDate == dto.MinimumDate).ToList(); foreach (var review in reviewsFromWeb) { var revInDb = await _repo.GetReview(review.PenName, review.BookAsin, review.ReviewDate, review.ReviewTitle); if (revInDb == null) { reviewsToAdd.Add(review); count++; } } _repo.AddMultiple(reviewsToAdd); if (await _repo.SaveAll()) { return(Ok(count)); } } catch (System.Exception ex) { return(BadRequest(ex)); } return(BadRequest("Could not add reviews")); }
public async Task ValidateForCreation(ReviewForCreationDto reviewForCreation) { Validate(reviewForCreation); await ValidateFilm(reviewForCreation.FilmId); ThrowValidationErrorsIfNotEmpty(); }
public async Task <IActionResult> Create(ReviewForCreationDto reviewForCreation) { await _reviewValidatorService.ValidateForCreation(reviewForCreation); await _reviewService.Create(reviewForCreation); return(Ok()); }
public async Task Create(ReviewForCreationDto reviewForCreation) { var review = _mapper.Map <Domain.Entities.Review>(reviewForCreation); review.UserId = (int)_currentUserService.UserId; _uow.Repository <Domain.Entities.Review>().Add(review); await _uow.SaveAsync(); }
public async Task <IActionResult> CreateReviewForProduct(Guid productId, [FromBody] ReviewForCreationDto review) { var reviewEntity = _mapper.Map <Review>(review); _repository.Review.CreateReviewForProduct(productId, reviewEntity); await _repository.SaveAsync(); var reviewDto = _mapper.Map <ReviewDto>(reviewEntity); return(CreatedAtRoute("GetReviewForProduct", new { productId, id = reviewDto.Id }, reviewDto)); }
public async Task <IActionResult> AddReviewForBook(int id, [FromBody] ReviewForCreationDto reviewForCreationDto) { if (reviewForCreationDto == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var authId = 0; int.TryParse(User.FindFirst(ClaimTypes.NameIdentifier).Value, out authId); var user = await _repo.GetUser(authId); if (user == null) { return(Unauthorized()); } var bookFromRepo = await _repo.GetBook(id); if (bookFromRepo == null) { return(NotFound()); } if (await _repo.ReviewExists(user.Id, id)) { return(BadRequest("You've already reviewed this book")); } var review = new Review() { UserId = user.Id, BookId = bookFromRepo.Id, Content = reviewForCreationDto.Content, Rating = reviewForCreationDto.Rating }; _repo.Add(review); if (!await _repo.SaveAll()) { throw new Exception($"Book review for id {id} failed on save."); } return(StatusCode(201)); }
public bool Create(ReviewForCreationDto reviewForCreation) { try { Review DataEntity = _mapper.Map <Review>(reviewForCreation); _repository.Create(DataEntity); _repository.Save(); return(true); } catch (Exception ex) { _logger.LogError($"Something went wrong inside CreateReview action: {ex.Message}"); throw new Exception(); } }
public async Task <IActionResult> AddReview(Guid recipientId, ReviewForCreationDto reviewIntake) { var senderId = Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); var sender = await _genUserRepo.GetByIdAsync(senderId); if (sender == null) { return(Unauthorized()); } if (await _repo.GetReview(senderId, recipientId) != null) { return(BadRequest("You already gave a review to this person")); } var recipient = await _genUserRepo.GetByIdAsync(recipientId); if (recipient == null) { return(NotFound()); } if (recipient.IsTrainer == false) { return(BadRequest("You can only give review to trainer")); } var newReview = new Review { SenderId = senderId, RecipientId = recipientId, Stars = reviewIntake.Stars, CreatedDate = DateTime.Now, Content = reviewIntake.Content, }; _genReviewRepo.Add(newReview); if (await _genReviewRepo.SaveAll()) { return(Ok()); } return(BadRequest("Failed to add review")); }
public async Task <IActionResult> CreateReview(string name, [FromBody] ReviewForCreationDto review) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!_itemRepository.ItemExists(name)) { return(NotFound()); } var reviewForCreation = _mapper.Map <Review>(review); await _itemRepository.LeaveReviewAsync(name, reviewForCreation); _logger.LogInformation($"Review created for item:{name}"); return(Ok()); }
public async Task <IActionResult> CreateReview([FromBody] ReviewForCreationDto review, [FromHeader(Name = "Accept")] string mediaType) { if (review == null) { return(BadRequest()); } var reviewEntity = Mapper.Map <Review>(review); await _reviewRepository.AddReview(reviewEntity); if (!await _reviewRepository.Save()) { throw new Exception("Creating a review failed on save."); } var reviewToReturn = Mapper.Map <ReviewDto>(reviewEntity); if (mediaType == "application/vnd.gamextime.hateoas+json") { var links = CreateLinksForReview(reviewToReturn.Id, null); var linkedResourceToReturn = reviewToReturn.ShapeData(null) as IDictionary <string, object>; linkedResourceToReturn.Add("links", links); return(CreatedAtRoute("GetReview", new { id = linkedResourceToReturn["Id"] }, linkedResourceToReturn)); } else { return(CreatedAtRoute("GetReview", new { id = reviewToReturn.Id }, reviewToReturn)); } //var links = CreateLinksForReview(reviewToReturn.Id, null); //var linkedResourceToReturn = reviewToReturn.ShapeData(null) // as IDictionary<string, object>; //linkedResourceToReturn.Add("links", links); //return CreatedAtRoute("GetReview", // new { id = linkedResourceToReturn["Id"] }, linkedResourceToReturn); }
public async Task <IActionResult> AddReviewForUser(int userId, [FromForm] ReviewForCreationDto reviewForCreationDto) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var userFromRepo = await _repo.GetUser(userId); var file = reviewForCreationDto.File; var uploadResult = new ImageUploadResult(); if (file.Length > 0) { using (var stream = file.OpenReadStream()) { var uploadParams = new ImageUploadParams() { File = new FileDescription(file.Name, stream), Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face") }; uploadResult = _cloudinary.Upload(uploadParams); } reviewForCreationDto.Url = uploadResult.Url.ToString(); reviewForCreationDto.PublicId = uploadResult.PublicId; } var review = _mapper.Map <Review>(reviewForCreationDto); userFromRepo.Reviews.Add(review); if (await _repo.SaveAll()) { var reviewToReturn = _mapper.Map <ReviewForReturnDto>(review); return(CreatedAtRoute("GetReview", new { userId = userId, id = review.Id }, reviewToReturn)); } return(BadRequest("Could not add the photo review")); }
public async Task <IActionResult> AddReview(ReviewForCreationDto reviewIntake) { if (await UserAlreadyReviewed(reviewIntake.RecieverId)) { return(Unauthorized("You already gave a review to this person")); } var newReview = new Review { SenderId = CurrentUserId, RecipientId = reviewIntake.RecieverId, Stars = reviewIntake.Stars, CreatedDate = DateTime.Now, Content = reviewIntake.Content, }; await _reviewsRepo.Add(newReview); return(Ok()); }
public async Task <IActionResult> AddReviews([FromForm] ReviewForCreationDto dto) { int reviewerId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); int count = 0; try { var dt = GetTableFromExcel(dto.File); var minDate = dt.Compute("MIN(Date)", null).ToString(); // dto.MinimumDate = DateTime.ParseExact(minDate, "MM/dd/yyyy", CultureInfo.InvariantCulture); dto.MinimumDate = DateTime.Parse(minDate); var reviewsFromWeb = GetReviewsFromWeb(dto, reviewerId); foreach (var review in reviewsFromWeb) { var dataRow = dt.Select("Name = '" + review.PenName + "'").FirstOrDefault(); if (dataRow != null) { var date = dataRow["Date"].ToString(); var reviewDate = DateTime.Parse(date); if (reviewDate == review.ReviewDate) { var revInDb = await _repo.GetReview(review.PenName, review.BookAsin, review.ReviewDate, review.ReviewTitle); if (revInDb == null) { _repo.Add(review); count++; } } } } await _repo.SaveAll(); } catch (Exception ex) { return(BadRequest(ex)); } return(Ok(count)); }
public async Task <IActionResult> ReviewAlbumAsync([FromBody] ReviewForCreationDto newReview) { if (!ModelState.IsValid) { return(BadRequest("Input is invalid")); } Review review = this._mapper.Map <Review>(newReview); if (await this._reviewService.ReviewAlbum(review)) { ReviewForListDto reviewToReturn = this._mapper.Map <ReviewForListDto>(review); var listUserReview = await this._reviewService.GetListUserReview(new Guid(newReview.AlbumId.ToString())); var senderId = User.FindFirstValue(ClaimTypes.NameIdentifier); var senderName = User.FindFirstValue(ClaimTypes.Name); await this._notifService.SendNoti(new Guid(senderId), listUserReview.ToList(), senderName + " commented to your post!"); return(Ok(reviewToReturn)); } return(BadRequest("Failed to review album")); }
public async Task <IActionResult> CreateReviewForRestaurant(Guid restaurantId, ReviewForCreationDto review) { // check if restaurant exists if (!await _knockRepository.RestaurantExists(restaurantId)) { return(NotFound()); } // map review to review var reviewEntity = _mapper.Map <Review>(review); // get user Guid sender = Guid.Parse(User.FindFirst(ClaimTypes.Name)?.Value); reviewEntity.UserId = sender; // if exists add review _knockRepository.AddReview(restaurantId, reviewEntity); if (await _knockRepository.SaveChangesAsync()) { // update average await _knockRepository.GetAverageRatingAsync(restaurantId); } // remap to dto var reviewToReturn = _mapper.Map <ReviewDto>(reviewEntity); return(CreatedAtRoute(nameof(GetReviewForRestaurant), new { restaurantId = restaurantId, reviewId = reviewToReturn.Id }, reviewToReturn)); }
private List <Review> GetReviewsFromWeb(ReviewForCreationDto dto, int reviewerId) { List <Review> revList = new List <Review>(); int nextPageNo = 0; bool minDate = false; while (nextPageNo != -1) { Review review; string url = ""; string nextPageId; if (dto.Country.ToLower() == "us") { url = "https://www.audible.com/pd/reviews?country=US&asin=" + dto.BookAsin + "&sort=MostRecent&page=" + nextPageNo; nextPageId = "nextReviewsPageNumberUS"; } else { url = "https://www.audible.co.uk/pd/reviews?country=UK&asin=" + dto.BookAsin + "&sort=MostRecent&page=" + nextPageNo; nextPageId = "nextReviewsPageNumberUK"; } var web = new HtmlWeb(); var doc = web.Load(url); var listItems = doc.DocumentNode.SelectNodes("//li/a[contains(@class, 'bc-color-link')]"); foreach (var node in listItems) { var penName = node.InnerText; var dateNode = node.ParentNode.ParentNode.Descendants("li") .Where(d => d.Attributes["class"].Value.Contains("bc-color-secondary")) .FirstOrDefault(); var date = Regex.Replace(dateNode.InnerText, @"\s+", string.Empty); DateTime reviewDate; if (dto.Country.ToLower() == "us") { reviewDate = DateTime.Parse(date); } else { reviewDate = DateTime.ParseExact(date, "dd-MM-yy", CultureInfo.InvariantCulture); } //checking minimum date if (dto.MinimumDate > reviewDate) { minDate = true; break; } var rawReview = dateNode.ParentNode.ParentNode.ParentNode.ParentNode.ParentNode.NextSibling.NextSibling .SelectSingleNode("h4"); string reviewTitle = ""; if (rawReview != null) { reviewTitle = rawReview.InnerText.Trim(); } //creating new review if (penName.ToLower() != "anonymous user") { review = new Review(); review.PenName = penName; review.ReviewDate = reviewDate; review.ReviewTitle = reviewTitle; review.BookAsin = dto.BookAsin; review.Country = dto.Country; review.ReviewerId = reviewerId; revList.Add(review); } } string nextPage = "0"; try { nextPage = doc.GetElementbyId(nextPageId).GetAttributeValue("value", ""); nextPageNo = Convert.ToInt32(nextPage); } catch (Exception) { nextPageNo = -1; } if (minDate) { nextPageNo = -1; } } return(revList); }
public async Task <IActionResult> CreateReviewForAlbum([FromRoute] Guid albumId, [FromBody] ReviewForCreationDto reviewToCreate) { if (reviewToCreate == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(new ErrorProcessingEntityObjectResult(ModelState)); } var reviewToCreateEntity = Mapper.Map <Review>(reviewToCreate); reviewToCreateEntity.Id = Guid.NewGuid(); reviewToCreateEntity.AlbumId = albumId; _reviewRepository.Create(reviewToCreateEntity); if (!await _reviewRepository.SaveChangesAsync()) { throw new Exception($"adding review to album {albumId} failed"); } return(CreatedAtRoute("GetReviewForAlbum", new { albumId, id = reviewToCreateEntity.Id }, reviewToCreateEntity)); }