private void SetupFakeWithIdQuery(Status[] status, HashSet <Guid> ids)
{
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false))
.Returns(schema);
A.CallTo(() => contentRepository.QueryAsync(app, schema, A <Status[]> .That.IsSameSequenceAs(status), ids))
.Returns(new List <IContentEntity> {
content
});
A.CallTo(() => contentRepository.CountAsync(app, schema, A <Status[]> .That.IsSameSequenceAs(status), ids))
.Returns(123);
}
public async Task <IActionResult> GetContents(string name, [FromQuery] bool nonPublished = false, [FromQuery] bool hidden = false)
{
var schemaEntity = await schemas.FindSchemaByNameAsync(AppId, name);
if (schemaEntity == null)
{
return(NotFound());
}
var query = Request.QueryString.ToString();
var taskForContents = contentRepository.QueryAsync(schemaEntity.Id, nonPublished, query, App);
var taskForCount = contentRepository.CountAsync(schemaEntity.Id, nonPublished, query, App);
await Task.WhenAll(taskForContents, taskForCount);
var response = new AssetsDto
{
Total = taskForCount.Result,
Items = taskForContents.Result.Take(200).Select(x =>
{
var itemModel = SimpleMapper.Map(x, new ContentDto());
if (x.Data != null)
{
itemModel.Data = x.Data.ToApiModel(schemaEntity.Schema, App.LanguagesConfig);
}
return(itemModel);
}).ToArray()
};
return(Ok(response));
}
public async Task <ActionResult <long> > GetContentCount(CancellationToken cancellationToken = default)
{
return(await _memoryCache.GetOrCreateAsync($"{nameof(ContentController)}_{nameof(GetContentCount)}", async (entry) =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
return await _contentRepository.CountAsync(cancellationToken);
}));
}
public async Task <IActionResult> GetContents(string name, [FromQuery] string ids = null)
{
var schemaEntity = await FindSchemaAsync(name);
var idsList = new HashSet <Guid>();
if (!string.IsNullOrWhiteSpace(ids))
{
foreach (var id in ids.Split(','))
{
if (Guid.TryParse(id, out var guid))
{
idsList.Add(guid);
}
}
}
var isFrontendClient = User.IsFrontendClient();
var query = Request.QueryString.ToString();
var taskForItems = contentRepository.QueryAsync(App, schemaEntity.Id, isFrontendClient, idsList, query);
var taskForCount = contentRepository.CountAsync(App, schemaEntity.Id, isFrontendClient, idsList, query);
await Task.WhenAll(taskForItems, taskForCount);
var response = new AssetsDto
{
Total = taskForCount.Result,
Items = taskForItems.Result.Take(200).Select(x =>
{
var itemModel = SimpleMapper.Map(x, new ContentDto());
if (x.Data != null)
{
itemModel.Data = x.Data.ToApiModel(schemaEntity.Schema, App.LanguagesConfig, null, !isFrontendClient);
}
return(itemModel);
}).ToArray()
};
return(Ok(response));
}
public async Task IndexAsnyc(CancellationToken cancellationToken = default)
{
await Sync.WaitAsync(cancellationToken);
try {
if (!await _searchRepository.IndexExistsAsync(cancellationToken))
{
_logger.LogInformation("Creating Elastic index");
await _searchRepository.CreateIndexAsync(cancellationToken);
}
var expectedCount = await _contentRepository.CountAsync(cancellationToken);
var actualCount = await _searchRepository.CountAsync(cancellationToken);
if (expectedCount != actualCount)
{
var count = 0;
var page = 1;
var pageSize = 1000;
while (count < expectedCount)
{
_logger.LogInformation("Indexing elastic documents {Count} / {Total}", count, expectedCount);
var docs = await _contentRepository.ListAsync(page ++, pageSize, cancellationToken);
await _searchRepository.IndexAsync(docs.Select(_mapper.Map <Models.Elastic.Content>), cancellationToken);
count += docs.Count;
}
}
_logger.LogInformation("Elastic index is up to date");
}
finally {
Sync.Release();
}
}
