public AveragePropertyRating[] GetAveragePropertyRatings(string productId)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
var favoriteProperties = GetProductFavoriteProperties(productId);
if (!favoriteProperties.Any())
{
return(new AveragePropertyRating[0]);
}
var reviews = repository.CustomerReviews.Where(r => r.ProductId == productId && r.IsActive).ToArray();
var ratings = new List <AveragePropertyRating>();
foreach (FavoriteProperty property in favoriteProperties)
{
var rating = AbstractTypeFactory <AveragePropertyRating> .TryCreateInstance();
rating.FavoriteProperty = property;
var values = reviews.SelectMany(x => x.PropertyValues.Where(v => v.PropertyId == property.Id));
if (values.Any())
{
rating.Rating = values.Average(x => x.Rating);
}
ratings.Add(rating);
}
return(ratings.ToArray());
}
}
private void CalculateRating(ICustomerReviewRepository customerReviewRepository, CustomerReviewEntity review)
{
var reviews = customerReviewRepository
.CustomerReviews
.Where(r => r.ProductId == review.ProductId && r.Id != review.Id)
.ToList();
reviews.Add(review);
var productRatingValue = RateCalculationUtil.CalculateProductRating(reviews);
using (var productRatingRepository = _productRatingRepositoryFactory())
using (var changeTracker = GetChangeTracker(productRatingRepository))
{
var productRating = productRatingRepository.GetProductRatingByProductId(review.ProductId);
if (productRating == null)
{
productRating = AbstractTypeFactory <ProductRatingEntity> .TryCreateInstance();
productRating.ProductId = review.ProductId;
productRating.Rating = productRatingValue;
productRatingRepository.Add(productRating);
}
else
{
changeTracker.Attach(productRating);
productRating.Rating = productRatingValue;
}
CommitChanges(productRatingRepository);
}
}
public CustomerReviewService(
ICustomerReviewRepository customerReviewRepository,
ICurrentUserProvider currentUserProvider,
IMapper mapper)
: base(customerReviewRepository, mapper)
{
_currentUserProvider = currentUserProvider;
}
public void DeleteCustomerReviews(string[] ids)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
repository.DeleteCustomerReviews(ids);
CommitChanges(repository);
}
}
public CustomerReview GetById(string id)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
CustomerReviewEntity entity = repository.GetCustomerReview(id);
return(entity.ToModel(AbstractTypeFactory <CustomerReview> .TryCreateInstance()));
}
}
public FavoriteProperty[] GetProductFavoriteProperties(string productId)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
return(repository.GetProductFavoriteProperties(productId).
Select(x => x.ToModel(AbstractTypeFactory <FavoriteProperty> .TryCreateInstance())).
ToArray());
}
}
public CustomerReview[] GetByIds(string[] ids)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
return(repository.
GetByIds(ids).
Select(x => x.ToModel(AbstractTypeFactory <CustomerReview> .TryCreateInstance())).
ToArray());
}
}
public GenericSearchResult <CustomerReview> SearchCustomerReviews(CustomerReviewSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException($"{ nameof(criteria) } must be set");
}
var retVal = new GenericSearchResult <CustomerReview>();
using (ICustomerReviewRepository repository = _repositoryFactory())
{
IQueryable <CustomerReviewEntity> query = repository.CustomerReviews;
if (!criteria.ProductIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.ProductIds.Contains(x.ProductId));
}
if (criteria.IsActive.HasValue)
{
query = query.Where(x => x.IsActive == criteria.IsActive);
}
if (!criteria.SearchPhrase.IsNullOrEmpty())
{
query = query.Where(x => x.Content.Contains(criteria.SearchPhrase));
}
SortInfo[] sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = "CreatedDate", SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
retVal.TotalCount = query.Count();
List <string> customerReviewIds = query.Skip(criteria.Skip)
.Take(criteria.Take)
.Select(x => x.Id)
.ToList();
retVal.Results = _customerReviewService.GetByIds(customerReviewIds.ToArray())
.OrderBy(x => customerReviewIds.IndexOf(x.Id)).ToList();
return(retVal);
}
}
public void UpdateCustomerReviewVotesCount(ICustomerReviewRepository repository, string[] reviewIds)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
var query = repository.GetReviewByIds(reviewIds);
foreach (var item in query)
{
item.HelpfullVotesCount = item.CustomerReviewVotes.Count(x => (x.ReviewRate == VoteRate.Helpfull) && (x.CustomerReviewId == item.Id));
item.UselessVotesCount = item.CustomerReviewVotes.Count(x => (x.ReviewRate == VoteRate.Useless) && (x.CustomerReviewId == item.Id));
item.TotalVotesCount = item.CustomerReviewVotes.Count(x => x.CustomerReviewId == item.Id);
}
}
public void SaveCustomerReview(CustomerReview item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
var pkMap = new PrimaryKeyResolvingMap();
using (ICustomerReviewRepository repository = _repositoryFactory())
{
using (ObservableChangeTracker changeTracker = GetChangeTracker(repository))
{
if (!item.IsTransient())
{
var sourceEntity = AbstractTypeFactory <CustomerReviewEntity> .TryCreateInstance().FromModel(item, pkMap);
var existsEntity = repository.GetCustomerReview(item.Id);
if (existsEntity != null)
{
changeTracker.Attach(existsEntity);
sourceEntity.Patch(existsEntity);
}
else
{
repository.Add(sourceEntity);
}
}
else
{
item.Id = Guid.NewGuid().ToString("N");
foreach (var value in item.PropertyValues)
{
value.ReviewId = item.Id;
}
var sourceEntity = AbstractTypeFactory <CustomerReviewEntity> .TryCreateInstance().FromModel(item, pkMap);
repository.Add(sourceEntity);
}
CommitChanges(repository);
pkMap.ResolvePrimaryKeys();
}
}
}
public AverageProductRating GetAverageProductRating(string productId)
{
using (ICustomerReviewRepository repository = _repositoryFactory())
{
var reviews = repository.CustomerReviews.Where(x => x.ProductId == productId && x.IsActive).ToArray();
var result = AbstractTypeFactory <AverageProductRating> .TryCreateInstance();
result.ProductId = productId;
if (!reviews.Any())
{
return(result);
}
result.Rating = reviews.Average(x => x.ProductRating);
result.ReviewsCount = reviews.Length;
return(result);
}
}
protected virtual IQueryable <CustomerReviewEntity> BuildQuery(ICustomerReviewRepository repository, CustomerReviewSearchCriteria criteria)
{
var query = repository.CustomerReviews;
if (!criteria.ProductIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.ProductIds.Contains(x.ProductId));
}
if (criteria.IsActive.HasValue)
{
query = query.Where(x => x.IsActive == criteria.IsActive);
}
if (!criteria.SearchPhrase.IsNullOrEmpty())
{
query = query.Where(x => x.ReviewContent.Contains(criteria.SearchPhrase));
}
return(query);
}
private static IQueryable <CustomerReviewEntity> BuildCustomerReviewsQuery(
ICustomerReviewRepository repository,
CustomerReviewSearchCriteria criteria)
{
var query = repository.CustomerReviews;
if (!criteria.ProductIds.IsNullOrEmpty())
{
query = query.Where(entity => criteria.ProductIds.Contains(entity.ProductId));
}
if (criteria.IsActive.HasValue)
{
query = query.Where(entity => entity.IsActive == criteria.IsActive);
}
if (!criteria.SearchPhrase.IsNullOrEmpty())
{
query = query.Where(entity => entity.Content.Contains(criteria.SearchPhrase));
}
return(query.OrderBySortInfos(CreateSortInfo(criteria)));
}
