public IEnumerable <Document> List()
{
logger.LogDebug("Listando documentos");
var query = new DocumentsQuery(node.Blockchain);
return(query.Execute());
}
public async Task <IActionResult> Get()
{
var query = new DocumentsQuery();
var documents = await _messageDispatcher.Execute(query);
return(Json(documents));
}
public async Task ItShouldGetDocumentsByClosedCommentPeriod()
{
var query = new DocumentsQuery
{
CommentPeriod = CommentPeriodStatus.Closed,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.NotContain(document => document.CommentStartDate <= DateTimeOffset.Now && DateTimeOffset.Now <= document.CommentDueDate);
}
public async Task ItShouldGetPublicSubmissions()
{
var query = new DocumentsQuery
{
Type = DocumentType.PublicSubmission,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.OnlyContain(document => document.DocumentType == "Public Submission");
}
public async Task <HttpResponseMessage> Get([FromUri] DocumentsQuery model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
ModelState));
}
var result = await service.Query(model);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task ItShouldGetDocumentsByDocket()
{
var query = new DocumentsQuery
{
DocketId = "DOI-2017-0002",
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.OnlyContain(document => document.DocketId == "DOI-2017-0002")
.And.OnlyContain(document => document.DocumentId.StartsWith("DOI-2017-0002-"));
}
public async Task ItShouldGetDocumentsByCommentPeriodEndDate()
{
var endDate = DateTimeOffset.Parse("2017-01-01T23:59:59-08:00");
var query = new DocumentsQuery
{
CommentPeriodEndDate = endDate,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.OnlyContain(document => document.CommentDueDate.HasValue && endDate >= document.CommentDueDate.Value);
}
public async Task ItShouldGetDocumentsByCommentPeriodStartDate()
{
var startDate = DateTimeOffset.Parse("2017-01-01");
var query = new DocumentsQuery
{
CommentPeriodStartDate = startDate,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.OnlyContain(document => document.CommentStartDate >= startDate);
}
public async Task ItShouldGetDocumentsByFederalAgencies()
{
var query = new DocumentsQuery
{
FederalAgencies = new HashSet <string>
{
"DOI",
"EPA"
},
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should()
.NotBeNullOrEmpty()
.And.OnlyContain(document => document.AgencyAcronym == "DOI" || document.AgencyAcronym == "EPA");
}
private void Querying(DateTimeOffset?postedStartDate, IActorRef indexManager, RegulationsGovClient apiClient)
{
ReceiveAsync <int>(async pageOffset =>
{
var logger = Context.GetLogger();
try
{
var query = new DocumentsQuery
{
SortBy = SortFields.PostedDate,
SortOrder = SortOrderType.Ascending,
ResultsPerPage = 1000,
PageOffset = pageOffset,
};
logger.Info(string.Join("; ", query.Select(x => $"{x.Key} = {string.Join(", ", x.Value)}")));
var result = await apiClient.GetDocuments(query);
if (result.Documents == null || result.Documents.Count == 0)
{
logger.Info("Reached the end. Waiting a bit to get more.");
Context.System.Scheduler.ScheduleTellOnce(TimeSpan.FromMinutes(1), Self, pageOffset, Self);
}
else
{
logger.Info($"Got {result.Documents.Count} documents, {pageOffset}/{result.TotalNumRecords} total available");
indexManager.Tell(result.Documents);
Self.Tell(pageOffset + result.Documents.Count);
}
}
catch (ApiException ae) when((int)ae.StatusCode == 429)
{
logger.Error(ae, "Caught API exception; waiting a bit to send resend request");
Context.System.Scheduler.ScheduleTellOnce(TimeSpan.FromMinutes(1), Self, pageOffset, Self);
}
catch (Exception e)
{
logger.Error(e, "Caught other exception; retrying");
Self.Tell(pageOffset);
}
});
Self.Tell(0);
}
public async Task <PagedQueryResult <DocumentRead> > Query(DocumentsQuery model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var userId = currentUserProvider.GetUserId();
var documents = Query(userId);
if (!string.IsNullOrWhiteSpace(model.Filter))
{
// ReSharper disable ImplicitlyCapturedClosure
documents = documents.Where(d =>
d.Title.Contains(model.Filter));
// ReSharper restore ImplicitlyCapturedClosure
}
documents = documents.OrderBy(model.OrderByClause);
if (model.Skip > 0)
{
documents = documents.Skip(model.Skip);
}
var data = await documents.Take(model.Top).ToListAsync();
var count = string.IsNullOrWhiteSpace(model.Filter) ?
// ReSharper disable ImplicitlyCapturedClosure
await dataContext.Documents.LongCountAsync(d =>
// ReSharper restore ImplicitlyCapturedClosure
d.UserId == userId ||
d.Shares.Any(s => s.UserId == userId)) :
await dataContext.Documents.LongCountAsync(d =>
(d.UserId == userId ||
d.Shares.Any(s => s.UserId == userId)) &&
d.Title.Contains(model.Filter));
return(new PagedQueryResult <DocumentRead>(data, count));
}
public async Task<PagedQueryResult<DocumentRead>> Query(DocumentsQuery model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var userId = currentUserProvider.GetUserId();
var documents = Query(userId);
if (!string.IsNullOrWhiteSpace(model.Filter))
{
// ReSharper disable ImplicitlyCapturedClosure
documents = documents.Where(d =>
d.Title.Contains(model.Filter));
// ReSharper restore ImplicitlyCapturedClosure
}
documents = documents.OrderBy(model.OrderByClause);
if (model.Skip > 0)
{
documents = documents.Skip(model.Skip);
}
var data = await documents.Take(model.Top).ToListAsync();
var count = string.IsNullOrWhiteSpace(model.Filter) ?
// ReSharper disable ImplicitlyCapturedClosure
await dataContext.Documents.LongCountAsync(d =>
// ReSharper restore ImplicitlyCapturedClosure
d.UserId == userId ||
d.Shares.Any(s => s.UserId == userId)) :
await dataContext.Documents.LongCountAsync(d =>
(d.UserId == userId ||
d.Shares.Any(s => s.UserId == userId)) &&
d.Title.Contains(model.Filter));
return new PagedQueryResult<DocumentRead>(data, count);
}
public async Task ItShouldGetReallyOldDocuments()
{
var query = new DocumentsQuery
{
ResultsPerPage = 10,
PageOffset = 0,
SortBy = SortFields.PostedDate,
SortOrder = SortOrderType.Ascending,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should().NotBeNullOrEmpty();
string lastDocumentId = null;
foreach (var document in results.Documents)
{
document.PostedDate.Should().BeOnOrBefore(DateTimeOffset.Parse("1900-04-10T00:00:00-05:00"));
string.CompareOrdinal(lastDocumentId, document.DocumentId).Should()
.Be(-1, $"Last document ID {lastDocumentId} should be before {document.DocumentId}");
}
}
public async Task ItShouldGetDocumentsByPage()
{
var query = new DocumentsQuery
{
DocketId = "DOI-2017-0002",
ResultsPerPage = 10,
PageOffset = 10,
SortBy = SortFields.DocId,
SortOrder = SortOrderType.Ascending,
};
var results = await _client.GetDocuments(query);
results.Should().NotBeNull();
results.Documents.Should().NotBeNullOrEmpty();
string lastDocumentId = null;
foreach (var document in results.Documents)
{
string.CompareOrdinal(lastDocumentId, document.DocumentId).Should()
.Be(-1, $"Last document ID {lastDocumentId} should be before {document.DocumentId}");
}
}
public async Task<IActionResult> Get()
{
var query = new DocumentsQuery();
var documents = await _messageDispatcher.Execute(query);
return Json(documents);
}
