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));
}
