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);
}));
}
public async Task <IPagedList <Model.CustomerReviews.CustomerReview> > SearchReviewsAsync(CustomerReviewSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchReviewsAsync), criteria.GetCacheKey());
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CustomerReviewCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(_apiChangesWatcher.CreateChangeToken());
var result = await _customerReviewsApi.SearchCustomerReviewsAsync(criteria.ToSearchCriteriaDto());
return new StaticPagedList <Model.CustomerReviews.CustomerReview>(result.Results.Select(x => x.ToCustomerReview()),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value);
}));
}
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 async Task CanDoCRUDandSearch()
{
IEnumerable <CustomerReview> result;
// Read non-existing item
result = await CustomerReviewService().GetAsync(new List <string>()
{
CustomerReviewId
});
Assert.NotNull(result);
Assert.Empty(result);
// Create
var item = new CustomerReview
{
Id = CustomerReviewId,
ProductId = ProductId,
CreatedDate = DateTime.Now,
CreatedBy = "initial data seed",
UserName = "******",
UserId = "dsdsd12dfsd",
Review = "Liked that",
Rating = 5,
StoreId = "Electronics",
Title = "my first review",
ReviewStatus = CustomerReviewStatus.New
};
await CustomerReviewService().SaveChangesAsync(new[] { item });
result = await CustomerReviewService().GetAsync(new List <string>()
{
CustomerReviewId
});
Assert.Single(result);
item = result.First();
Assert.Equal(CustomerReviewId, item.Id);
// Update
var updatedContent = "Updated content";
Assert.NotEqual(updatedContent, item.Review);
item.Review = updatedContent;
await CustomerReviewService().SaveChangesAsync(new[] { item });
result = await CustomerReviewService().GetAsync(new List <string>()
{
CustomerReviewId
});
Assert.Single(result);
item = result.First();
Assert.Equal(updatedContent, item.Review);
var criteria = new CustomerReviewSearchCriteria {
ProductIds = new[] { ProductId }
};
var cacheKeySearch = CacheKey.With(typeof(CustomerReviewSearchService), "SearchAsync", criteria.GetCacheKey());
_platformMemoryCacheMock.Setup(pmc => pmc.CreateEntry(cacheKeySearch)).Returns(_cacheEntryMock.Object);
var searchResult = await CustomerReviewSearchService().SearchAsync(criteria);
Assert.NotNull(searchResult);
Assert.Equal(1, searchResult.TotalCount);
Assert.Single(searchResult.Results);
// Delete
await CustomerReviewService().DeleteAsync(new[] { CustomerReviewId });
var getByIdsResult = await CustomerReviewService().GetAsync(new List <string>()
{
CustomerReviewId
});
Assert.NotNull(getByIdsResult);
Assert.Empty(getByIdsResult);
}
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;
}));
}
