public GenericSearchResult <CustomerReview> Search(CustomerReviewSearchCriteria criteria)
{
ValidateCriteria(criteria);
using (var repository = _repositoryFactory())
{
var reviewsQuery = BuildCustomerReviewsQuery(repository, criteria);
var reviewsTotalCount = reviewsQuery.Count();
var reviewsIdsQuery = reviewsQuery
.Skip(criteria.Skip)
.Take(criteria.Take)
.Select(entity => entity.Id);
var idsList = reviewsIdsQuery.ToList();
var idsArray = idsList.ToArray();
var reviews = _customerReviewService.GetByIds(idsArray);
var sortedReviews = reviews.OrderBy(review => idsList.IndexOf(review.Id));
var resultedReviews = sortedReviews.ToList();
return(new GenericSearchResult <CustomerReview>
{
TotalCount = reviewsTotalCount,
Results = resultedReviews
});
}
}
public async Task <IPagedList <CustomerReview> > SearchReviewsAsync(CustomerReviewSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchReviewsAsync), criteria.GetCacheKey());
return(await _memoryCache.GetOrCreateExclusiveAsync(
cacheKey,
async cacheEntry =>
{
var reviewsChangeToken = CustomerReviewCacheRegion.CreateChangeToken();
cacheEntry.AddExpirationToken(reviewsChangeToken);
var apiChangeToken = _apiChangesWatcher.CreateChangeToken();
cacheEntry.AddExpirationToken(apiChangeToken);
var searchCriteriaDto = criteria.ToApiSearchCriteria();
var foundCustomerReviews = await _customerReviewsApi.SearchCustomerReviewsAsync(searchCriteriaDto);
var totalCount = foundCustomerReviews.TotalCount ?? 0;
var customerReviews =
foundCustomerReviews.Results.Select(customerReview => customerReview.ToCustomerReview());
return new StaticPagedList <CustomerReview>(
customerReviews,
criteria.PageNumber,
criteria.PageSize,
totalCount);
}));
}
protected virtual Task LoadProductCustomerReviewsAsync(List <Product> products, WorkContext workContext)
{
if (products == null)
{
throw new ArgumentNullException(nameof(products));
}
foreach (var product in products)
{
//Lazy loading for customer reviews
product.CustomerReviews = new MutablePagedList <Model.CustomerReviews.CustomerReview>((pageNumber, pageSize, sortInfos) =>
{
var criteria = new CustomerReviewSearchCriteria
{
ProductIds = new[] { product.Id },
PageNumber = pageNumber,
PageSize = pageSize,
Sort = SortInfo.ToString(sortInfos),
};
var reviews = _customerReviewService.SearchReviews(criteria);
foreach (var review in reviews)
{
review.ReviewRatings = new MutablePagedList <Model.ReviewRatings.ReviewRating>((pn, ps, si) =>
{
return(_customerReviewService.GetReviewRatings(review.Id));
}, 1, CustomerReviewSearchCriteria.DefaultPageSize);
}
return(reviews);
}, 1, CustomerReviewSearchCriteria.DefaultPageSize);
}
return(Task.CompletedTask);
}
public async Task <ActionResult <IEnumerable <CustomerReview> > > GetCustomerReviews(
[FromBody] CustomerReviewSearchCriteria searchCriteria)
{
var reviews = await _customerReviewService.SearchReviewsAsync(searchCriteria);
return(reviews.ToList());
}
public IHttpActionResult SearchCustomerReviews([FromBody] CustomerReviewSearchCriteria criteria)
{
GenericSearchResult <CustomerReview> result = _customerReviewSearchService.SearchCustomerReviews(criteria);
return(Ok(result));
}
private static void ValidateCriteria(CustomerReviewSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException($"{nameof(criteria)} must be set");
}
}
protected virtual Task LoadProductCustomerReviewsAsync(Product[] products)
{
if (products == null)
{
throw new ArgumentNullException(nameof(products));
}
foreach (var product in products)
{
// Lazy loading for customer reviews
product.CustomerReviews = new MutablePagedList <Model.CustomerReviews.CustomerReview>(
(pageNumber, pageSize, sortInfos) =>
{
var criteria = new CustomerReviewSearchCriteria
{
ProductIds = new[] { product.Id },
PageNumber = pageNumber,
PageSize = pageSize,
Sort = SortInfo.ToString(sortInfos)
};
return(_customerReviewService.SearchReviews(criteria));
},
1,
CustomerReviewSearchCriteria.DefaultPageSize);
}
return(Task.CompletedTask);
}
public async Task <CustomerReviewSearchResult> SearchCustomerReviewsAsync(CustomerReviewSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchCustomerReviewsAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CustomerReviewCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <CustomerReviewSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = BuildQuery(repository, criteria);
var sortInfos = BuildSortExpression(criteria);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var customerReviewIds = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
var unorderedResults = await _customerReviewService.GetByIdsAsync(customerReviewIds);
result.Results = unorderedResults.OrderBy(x => Array.IndexOf(customerReviewIds, x.Id)).ToArray();
}
}
return result;
}));
}
public void CanDoCRUDandSearch()
{
// Read non-existing item
var getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
// Create
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
AuthorNickname = "John Doe",
Content = "Liked that",
Virtues = "Liked that!",
Disadvantages = "Not",
Rate = 3
};
CustomerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(CustomerReviewId, item.Id);
// Update
var updatedContent = "Updated content";
Assert.NotEqual(updatedContent, item.Content);
item.Content = updatedContent;
CustomerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = CustomerReviewService.GetByIds(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(updatedContent, item.Content);
// Search
Assert.Throws <ArgumentNullException>(() => CustomerReviewSearchService.SearchCustomerReviews(null));
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { ProductId }
};
var searchResult = CustomerReviewSearchService.SearchCustomerReviews(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
// Delete
CanDeleteCustomerReviews();
}
public static ReviewDto.CustomerReviewSearchCriteria ToSearchCriteriaDto(this CustomerReviewSearchCriteria criteria)
=> new ReviewDto.CustomerReviewSearchCriteria
{
IsActive = criteria.IsActive,
ProductIds = criteria.ProductIds,
Skip = criteria.Start,
Take = criteria.PageSize,
Sort = criteria.Sort
};
public void CanDoReviewCRUDandSearch()
{
//Read non-existing item
var getByIdsResult = _customerReviewService.GetReviewByIds(new[] { _customerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
//Create new item
var item = new CustomerReview
{
Id = _customerReviewId,
ProductId = _productId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
AuthorNickname = "John Doe",
Content = "Liked that"
};
_customerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = _customerReviewService.GetReviewByIds(new[] { _customerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(_customerReviewId, item.Id);
//Update existing item
var updatedConent = "Updated content";
Assert.NotEqual(updatedConent, item.Content);
item.Content = updatedConent;
_customerReviewService.SaveCustomerReviews(new[] { item });
getByIdsResult = _customerReviewService.GetReviewByIds(new[] { _customerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(updatedConent, item.Content);
//Search by creteria
Assert.Throws <ArgumentNullException>(() => _customerReviewSearchService.SearchCustomerReviews(null));
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { _productId }, AuthorId = _authorId
};
var searchResult = _customerReviewSearchService.SearchCustomerReviews(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
//Delete existing item
CanDeleteCustomerReviews();
}
public void SearchCustomerReviews_ExistingItem_ReturnsItem()
{
string testProductId = "testProductId";
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { testProductId }
};
var searchResult = CustomerReviewSearchService.SearchCustomerReviews(criteria);
Assert.NotNull(searchResult);
Assert.NotEqual(0, searchResult.TotalCount);
}
public GenericSearchResult <CustomerReview> SearchCustomerReviews(CustomerReviewSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException($"{ nameof(criteria) } must be set");
}
var retVal = new GenericSearchResult <CustomerReview>();
using (var repository = _repositoryFactory())
{
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.HasRating.HasValue)
{
query = query.Where(x => x.Rating > 0);
}
if (!criteria.SearchPhrase.IsNullOrEmpty())
{
query = query.Where(x => x.Content.Contains(criteria.SearchPhrase));
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = "CreatedDate", SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
retVal.TotalCount = query.Count();
var 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 SearchCustomerReviews_ShouldThrowArgumentNullException_IfCriteriaIsNull()
{
//arrange
CustomerReviewSearchCriteria criteria = null;
//act
Action act = () => _searchService.SearchCustomerReviews(criteria);
//assert
act.Should().Throw <ArgumentNullException>();
}
public static Api.CustomerReviewSearchCriteria ToApiSearchCriteria(this CustomerReviewSearchCriteria criteria)
{
var result = new Api.CustomerReviewSearchCriteria
{
IsActive = criteria.IsActive,
ProductIds = criteria.ProductIds,
Skip = criteria.Start,
Take = criteria.PageSize,
Sort = criteria.Sort
};
return(result);
}
public static ReviewDto.CustomerReviewSearchCriteria ToSearchCriteriaDto(this CustomerReviewSearchCriteria criteria)
{
var result = new ReviewDto.CustomerReviewSearchCriteria
{
IsActive = criteria.IsActive,
ProductIds = criteria.ProductIds,
Skip = criteria.Start,
Sort = criteria.Sort,
Take = criteria.PageSize
};
return(result);
}
public void SearchCustomerReviews_ShouldReturnActiveProducts_IfIsActiveIsSet()
{
//arrange
var isActive = _randomizer.Create <bool>();
var criteria = new CustomerReviewSearchCriteria
{
Take = 2,
IsActive = isActive
};
var customerReviewEntities = _randomizer
.Build <CustomerReviewEntity>()
.Without(p => p.IsActive)
.CreateMany(2);
customerReviewEntities.ElementAt(0).IsActive = isActive;
_repository.Setup(p => p.CustomerReviews).Returns(customerReviewEntities.AsQueryable());
var customerReviews = _randomizer.CreateMany <CustomerReview>(1);
customerReviews.ElementAt(0).Id = customerReviewEntities.ElementAt(0).Id;
_customerReviewService
.Setup(p => p.GetByIds(It.IsAny <string[]>()))
.Returns(customerReviews.ToArray());
//act
var result = _searchService.SearchCustomerReviews(criteria);
//assert
result.Should().BeEquivalentTo(new GenericSearchResult <CustomerReview>
{
TotalCount = 1,
Results = new[]
{
new CustomerReview
{
Id = customerReviews.ElementAt(0).Id,
CreatedDate = customerReviews.ElementAt(0).CreatedDate,
ModifiedDate = customerReviews.ElementAt(0).ModifiedDate,
CreatedBy = customerReviews.ElementAt(0).CreatedBy,
ModifiedBy = customerReviews.ElementAt(0).ModifiedBy,
AuthorNickname = customerReviews.ElementAt(0).AuthorNickname,
Content = customerReviews.ElementAt(0).Content,
IsActive = isActive,
ProductId = customerReviews.ElementAt(0).ProductId
}
}
});
}
public async Task <IPagedList <CutomerReviewModel> > SearchReviewAsync(CustomerReviewSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchReviewAsync), criteria.GetCacheKey());
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.ExpirationTokens.Add(CustomerReviewCacheRegion.CreateChangeToken(criteria.ProductIds.FirstOrDefault()));
cacheEntry.ExpirationTokens.Add(_apiChangesWatcher.CreateChangeToken());
var result = await _customerReviews.SearchCustomerReviewsAsync(criteria.ToSearchCriteriaDto());
return new StaticPagedList <CutomerReviewModel>(result.Results.Select(c => c.ToCustomerReview()),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value);
}
));
}
protected virtual IList <SortInfo> BuildSortExpression(CustomerReviewSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = nameof(CustomerReviewEntity.CreatedDate), SortDirection = SortDirection.Descending
}
};
}
return(sortInfos);
}
public decimal GetProductAverageRating(string id)
{
var criteria = new CustomerReviewSearchCriteria
{
ProductIds = new[] { id }
};
var reviews = SearchCustomerReviews(criteria);
var sum = 0m;
foreach (var review in reviews.Results)
{
sum += review.Rating;
}
return(Math.Round(sum / reviews.TotalCount, 1, MidpointRounding.AwayFromZero));
}
public void SearchCustomerReviewsTest()
{
// Arrange
var criteria = new CustomerReviewSearchCriteria
{
IsActive = true,
ProductIds = new string[1] {
_testProductId
}
};
// Act
GenericSearchResult <CustomerReview> result = _customerReviewSearchService.SearchCustomerReviews(criteria);
// Assert
Assert.Equal(1, result.TotalCount);
}
public void SearchCustomerReviews_ShouldReturnProductsByIds_IfProductIdsIsSet()
{
//arrange
var productIds = randomizer.CreateMany <string>(2).ToArray();
var criteria = new CustomerReviewSearchCriteria
{
ProductIds = productIds,
Take = 2
};
var customerReviewEntities = randomizer.CreateMany <CustomerReviewEntity>(2);
customerReviewEntities.ElementAt(0).ProductId = productIds[0];
repository.Setup(p => p.CustomerReviews).Returns(customerReviewEntities.AsQueryable());
var customerReviews = randomizer.CreateMany <CustomerReview>(1);
customerReviews.ElementAt(0).Id = customerReviewEntities.ElementAt(0).Id;
customerReviewService
.Setup(p => p.GetByIds(It.IsAny <string[]>()))
.Returns(customerReviews.ToArray());
//act
var result = service.SearchCustomerReviews(criteria);
//assert
result.Should().BeEquivalentTo(new GenericSearchResult <CustomerReview>
{
TotalCount = 1,
Results = new[]
{
new CustomerReview
{
Id = customerReviews.ElementAt(0).Id,
CreatedDate = customerReviews.ElementAt(0).CreatedDate,
ModifiedDate = customerReviews.ElementAt(0).ModifiedDate,
CreatedBy = customerReviews.ElementAt(0).CreatedBy,
ModifiedBy = customerReviews.ElementAt(0).ModifiedBy,
AuthorNickname = customerReviews.ElementAt(0).AuthorNickname,
Content = customerReviews.ElementAt(0).Content,
IsActive = customerReviews.ElementAt(0).IsActive,
ProductId = productIds[0]
}
}
});
}
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)));
}
protected virtual Task LoadProductCustomerReviewsAsync(List <Product> products, WorkContext workContext)
{
if (products == null)
{
throw new ArgumentNullException(nameof(products));
}
foreach (var product in products)
{
product.CustomerReviews = new MutablePagedList <Model.CustomerReviews.CustomerReview>((pageNumber, pageSize, sortInfos, @params) =>
{
var criteria = new CustomerReviewSearchCriteria()
{
PageNumber = pageNumber,
PageSize = pageSize,
ProductIds = new[] { product.Id },
Sort = SortInfo.ToString(sortInfos)
};
return(_customerReviewService.GetCustomerReviews(criteria));
}, 1, CustomerReviewSearchCriteria.DefaultPageSize);
}
return(Task.CompletedTask);
}
private async Task LoadProductCustomerReviewsAsync(List <Product> products)
{
if (products == null)
{
throw new ArgumentNullException(nameof(products));
}
foreach (var product in products)
{
//Lazy loading for customer reviews
product.CustomerReviews = new MutablePagedList <Model.CustomerReviews.CustomerReview>((pageNumber, pageSize, sortInfos) =>
{
var criteria = new CustomerReviewSearchCriteria
{
ProductIds = new[] { product.Id },
PageNumber = pageNumber,
PageSize = pageSize,
Sort = SortInfo.ToString(sortInfos),
};
return(_customerReviewService.SearchReviews(criteria));
}, 1, CustomerReviewSearchCriteria.DefaultPageSize);
product.AverageRating = await _customerReviewService.GetAverageRatingAsync(product.Id);
}
}
public IHttpActionResult SearchCustomerReviews(CustomerReviewSearchCriteria criteria)
{
var result = _customerReviewSearchService.SearchCustomerReviews(criteria);
return(Ok(result));
}
public async Task <ActionResult <CustomerReviewSearchResult> > SearchCustomerReviews([FromBody] CustomerReviewSearchCriteria criteria)
{
var result = await _customerReviewSearchService.SearchCustomerReviewsAsync(criteria);
return(result);
}
public async Task CanDoCRUDandSearch()
{
// Read non-existing item
var getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
// Create
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
CustomerName = "John Doe",
ReviewContent = "Liked that"
};
await CustomerReviewService.SaveCustomerReviewsAsync(new[] { item });
_mockCustomerReviewRepository.Setup(ss => ss.GetByIdsAsync(new[] { CustomerReviewId }))
.ReturnsAsync(new[] { new CustomerReviewEntity().FromModel(item, new PrimaryKeyResolvingMap()) });
getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(CustomerReviewId, item.Id);
// Update
var updatedContent = "Updated content";
Assert.NotEqual(updatedContent, item.ReviewContent);
item.ReviewContent = updatedContent;
await CustomerReviewService.SaveCustomerReviewsAsync(new[] { item });
getByIdsResult = await CustomerReviewService.GetByIdsAsync(new[] { CustomerReviewId });
Assert.Single(getByIdsResult);
item = getByIdsResult[0];
Assert.Equal(updatedContent, item.ReviewContent);
// Search
var mockReviews = new[] { new CustomerReviewEntity().FromModel(item, new PrimaryKeyResolvingMap()) }.AsQueryable().BuildMock();
_mockCustomerReviewRepository.SetupGet(x => x.CustomerReviews).Returns(mockReviews.Object);
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { ProductId }
};
var cacheKey = CacheKey.With(CustomerReviewSearchService.GetType(), nameof(CustomerReviewSearchService.SearchCustomerReviewsAsync), criteria.GetCacheKey());
_platformMemoryCacheMock.Setup(pmc => pmc.CreateEntry(cacheKey)).Returns(_cacheEntryMock.Object);
var searchResult = await CustomerReviewSearchService.SearchCustomerReviewsAsync(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
// Delete
_mockCustomerReviewRepository.Setup(ss => ss.GetByIdsAsync(new[] { CustomerReviewId }))
.ReturnsAsync(new CustomerReviewEntity[0]);
await CanDeleteCustomerReviews();
}
public IPagedList <CustomerReview> SearchReviews(CustomerReviewSearchCriteria criteria)
{
return(SearchReviewsAsync(criteria).GetAwaiter().GetResult());
}
public static AutoRestClients.TestCustomModule.WebModuleApi.Models.CustomerReviewSearchCriteria ToSearchCriteriaDto(this CustomerReviewSearchCriteria criteria)
{
var result = new AutoRestClients.TestCustomModule.WebModuleApi.Models.CustomerReviewSearchCriteria()
{
IsActive = criteria.IsActive,
ProductIds = criteria.ProductIds,
HasRating = criteria.HasRating,
Skip = criteria.Start,
Take = criteria.PageSize,
Sort = criteria.Sort,
};
return(result);
}
