private async Task LoadSitemapRecords(Store store, Sitemap sitemap, string baseUrl, Action <ExportImportProgressInfo> progressCallback = null)
{
var recordsLimitPerFile = SettingsManager.GetValue("Sitemap.RecordsLimitPerFile", 10000);
var filenameSeparator = SettingsManager.GetValue("Sitemap.FilenameSeparator", "--");
var sitemapItemSearchCriteria = new SitemapItemSearchCriteria
{
SitemapId = sitemap.Id,
Skip = 0,
Take = int.MaxValue
};
sitemap.Items = (await SitemapItemService.SearchAsync(sitemapItemSearchCriteria)).Results;
foreach (var recordProvider in SitemapItemRecordProviders)
{
//Log exceptions to prevent fail whole sitemap.xml generation
try
{
await recordProvider.LoadSitemapItemRecordsAsync(store, sitemap, baseUrl, progressCallback);
}
catch (Exception ex)
{
Logger.LogError(ex, $"Failed to load sitemap item records for store #{store.Id}, sitemap #{sitemap.Id} and baseURL '{baseUrl}'");
}
}
sitemap.PagedLocations.Clear();
var totalRecordsCount = sitemap.Items.SelectMany(x => x.ItemsRecords).GroupBy(x => x.Url).Count();
var pagesCount = totalRecordsCount > 0 ? (int)Math.Ceiling(totalRecordsCount / (double)recordsLimitPerFile) : 0;
for (var i = 1; i <= pagesCount; i++)
{
sitemap.PagedLocations.Add(new SitemapLocation(sitemap.Location, i, filenameSeparator).ToString(pagesCount > 1));
}
}
public async Task TestDataExport()
{
// Arrange
var sitemapSearchCriteria = new SitemapSearchCriteria
{
Skip = 0,
Take = int.MaxValue
};
var sitemapSearchResult = new GenericSearchResult <Sitemap>
{
TotalCount = TestSitemaps.Count,
Results = TestSitemaps
};
_sitemapService.Setup(service => service.SearchAsync(sitemapSearchCriteria))
.ReturnsAsync(sitemapSearchResult);
var sitemapItemSearchCriteria = new SitemapItemSearchCriteria
{
Skip = 0,
Take = int.MaxValue
};
var sitemapItemsSearchResult = new GenericSearchResult <SitemapItem>
{
TotalCount = TestSitemapItems.Count,
Results = TestSitemapItems
};
_sitemapItemService.Setup(service => service.SearchAsync(sitemapItemSearchCriteria))
.ReturnsAsync(sitemapItemsSearchResult);
string expectedJson;
using (var resourceStream = ReadEmbeddedResource("Resources.SerializedSitemapsData.json"))
using (var textReader = new StreamReader(resourceStream))
{
expectedJson = await textReader.ReadToEndAsync();
}
// Act
string actualJson;
using (var targetStream = new MemoryStream())
{
await _sitemapExportImport.DoExportAsync(targetStream, IgnoreProgressInfo, _cancellationToken.Object);
var targetStreamContents = targetStream.ToArray();
using (var copiedStream = new MemoryStream(targetStreamContents))
using (var textReader = new StreamReader(copiedStream))
{
actualJson = textReader.ReadToEnd();
}
}
// Assert
var expectedJObject = JsonConvert.DeserializeObject <JObject>(expectedJson);
var actualJObject = JsonConvert.DeserializeObject <JObject>(actualJson);
Assert.True(JToken.DeepEquals(expectedJObject, actualJObject));
}
public async Task <IActionResult> SearchSitemapItems([FromBody] SitemapItemSearchCriteria request)
{
if (request == null)
{
return(BadRequest("request is null"));
}
var searchSitemapItemResponse = await _sitemapItemService.SearchAsync(request);
return(Ok(searchSitemapItemResponse));
}
public virtual async Task <SitemapItemsSearchResult> SearchAsync(SitemapItemSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var result = AbstractTypeFactory <SitemapItemsSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = repository.SitemapItems;
if (!string.IsNullOrEmpty(criteria.SitemapId))
{
query = query.Where(x => x.SitemapId == criteria.SitemapId);
}
if (criteria.ObjectTypes != null)
{
query = query.Where(i =>
criteria.ObjectTypes.Contains(i.ObjectType, StringComparer.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(criteria.ObjectType))
{
query = query.Where(i => i.ObjectType.EqualsInvariant(criteria.ObjectType));
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = ReflectionUtility.GetPropertyName <SitemapItemEntity>(x => x.CreatedDate),
SortDirection = SortDirection.Descending
}
};
}
query = query.OrderBySortInfos(sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var sitemapItemsIds = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
result.Results = (await _sitemapItemService.GetByIdsAsync(sitemapItemsIds)).AsQueryable().OrderBySortInfos(sortInfos).ToArray();
}
}
return(result);
}
public virtual async Task <GenericSearchResult <SitemapItem> > SearchAsync(SitemapItemSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var cacheKey = CacheKey.With(GetType(), nameof(SearchAsync), criteria.GetCacheKey());
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(SitemapItemSearchCacheRegion.CreateChangeToken());
using (var repository = RepositoryFactory())
{
var searchResponse = new GenericSearchResult <SitemapItem>();
var query = repository.SitemapItems;
if (!string.IsNullOrEmpty(criteria.SitemapId))
{
query = query.Where(x => x.SitemapId == criteria.SitemapId);
}
if (criteria.ObjectTypes != null)
{
query = query.Where(i =>
criteria.ObjectTypes.Contains(i.ObjectType, StringComparer.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(criteria.ObjectType))
{
query = query.Where(i => i.ObjectType.EqualsInvariant(criteria.ObjectType));
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = ReflectionUtility.GetPropertyName <SitemapItemEntity>(x => x.CreatedDate),
SortDirection = SortDirection.Descending
}
};
}
query = query.OrderBySortInfos(sortInfos);
searchResponse.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var matchingSitemapItems = await query.Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
foreach (var sitemapItemEntity in matchingSitemapItems)
{
var sitemapItem = AbstractTypeFactory <SitemapItem> .TryCreateInstance();
if (sitemapItem != null)
{
searchResponse.Results.Add(sitemapItemEntity.ToModel(sitemapItem));
}
}
}
return searchResponse;
}
}));
}
public async Task <ActionResult <SitemapItemsSearchResult> > SearchSitemapItems([FromBody] SitemapItemSearchCriteria request)
{
if (request == null)
{
return(BadRequest("request is null"));
}
var result = await _sitemapItemSearchService.SearchAsync(request);
return(Ok(result));
}
