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