public async Task <IList <Audit> > ReadAuditsAsync(
int workspaceId,
DateTime startHour,
DateTime endHour,
IList <AuditActionId> actionTypes,
int batchSize,
long pageStart)
{
// Read Data grid settings specifically needed for audits
// -- This workspace's DataGridAudit ArtifactTypeId, action choiceIds
var auditArtifactTypeId = this.artifactRepository.ReadAuditArtifactTypeId(workspaceId);
var choiceIds = this.dataGridSettingsService.ReadActionChoiceIds(workspaceId, actionTypes);
await Task.WhenAll(auditArtifactTypeId, choiceIds);
// Pass the settings to the API, along with the batch args
var queryBatch = new AuditQueryBatch
{
Query = new AuditQuery
{
WorkspaceId = workspaceId,
StartTime = startHour,
EndTime = endHour,
ActionTypes = actionTypes
},
Start = pageStart,
Size = batchSize
};
return(await this.dataGridService.ReadAuditsAsync(queryBatch, auditArtifactTypeId.Result, choiceIds.Result));
}
private int GetQueryStart(AuditQueryBatch queryBatch)
{
try
{
return(Convert.ToInt32(queryBatch.Start + 1));
}
catch (OverflowException)
{
this.logger.LogWarning($"Overflow exception when trying to cast queryStart ({queryBatch.Start + 1}) to int");
throw;
}
}
public async Task ReadAuditsAsync_Success()
{
// Arrange
var queryBatch = new AuditQueryBatch
{
Query = new AuditQuery
{
WorkspaceId = 123
}
};
var queryStart = Convert.ToInt32(queryBatch.Start + 1);
var auditArtifactTypeId = 2;
var choiceIds = new[] { 1, 2 };
var testCondition = "TEST";
this.dataGridConditionBuilderMock.Setup(
m => m.BuildActionTimeframeCondition(choiceIds, queryBatch.Query.StartTime, queryBatch.Query.EndTime))
.Returns(testCondition);
var testResponse = new QueryResult();
this.auditManagerMock.Setup(
m =>
m.QueryAsync(queryBatch.Query.WorkspaceId,
It.Is <QueryRequest>(r => r.ObjectType.ArtifactTypeID == auditArtifactTypeId && r.Condition == testCondition),
queryStart,
queryBatch.Size,
It.Is <AuditQueryOptions>(o => o.ReturnRawDetails == true)))
.ReturnsAsync(testResponse);
var audits = new List <Audit>();
this.dataGridResponseAuditMapperMock.Setup(m => m.ResponseToAudits(testResponse, queryBatch.Query.WorkspaceId)).Returns(audits);
// Act
var result = await this.dataGridService.ReadAuditsAsync(queryBatch, auditArtifactTypeId, choiceIds);
// Assert
Assert.That(result, Is.EqualTo(audits));
this.auditLogObjectManagerFactoryMock.VerifyAll();
this.auditManagerMock.VerifyAll();
this.dataGridConditionBuilderMock.VerifyAll();
this.dataGridResponseAuditMapperMock.VerifyAll();
}
public async Task DataGrid_EndToEnd_ReadAudits()
{
var workspaceId = Config.WorkSpaceId;
var auditQuery = new AuditQuery
{
ActionTypes = new List <AuditActionId> {
AuditActionId.DocumentQuery
},
StartTime = DateTime.MinValue,
EndTime = DateTime.UtcNow,
WorkspaceId = workspaceId
};
var queryBatch = new AuditQueryBatch
{
Query = auditQuery,
Size = 50,
Start = 0
};
// However we grab this for testing...
var apiClientHelper = new ApiClientHelper();
var auditLogObjectManager = apiClientHelper.GetKeplerServiceReference <IExternalAuditLogObjectManager>();
// Mock it up for the implementation
var mockFactory = new Mock <IAuditLogObjectManagerFactory>();
mockFactory.Setup(m => m.GetManager()).Returns(() => auditLogObjectManager.Value);
var dataGridWorkspaceAuditService = DataGridEndToEnd.SetUpWorkspaceAuditService(mockFactory.Object);
var result = await dataGridWorkspaceAuditService.ReadAuditsAsync(workspaceId, auditQuery.StartTime,
auditQuery.EndTime,
auditQuery.ActionTypes, queryBatch.Size, queryBatch.Start);
var resultMessages =
result.Select(
r =>
$"AuditId: {r.AuditID}, UserId {r.UserID}, Action: {r.Action}, ArtifactID: {r.ArtifactID}, ExecutionTime: {r.ExecutionTime}, WorkspaceId: {r.WorkspaceId}, TimeStamp: {r.TimeStamp}, Details: {r.Details}");
var finalMessage = string.Join("||", resultMessages);
Assert.Pass($"Test Passed - ResultCount {result.Count} -- {finalMessage}");
}
public void ReadAuditsAsync_Failure()
{
// Arrange
var queryBatch = new AuditQueryBatch
{
Query = new AuditQuery
{
WorkspaceId = 123
}
};
var queryStart = Convert.ToInt32(queryBatch.Start + 1);
var auditArtifactTypeId = 2;
var choiceIds = new[] { 1, 2 };
var testCondition = "TEST";
this.dataGridConditionBuilderMock.Setup(
m => m.BuildActionTimeframeCondition(choiceIds, queryBatch.Query.StartTime, queryBatch.Query.EndTime))
.Returns(testCondition);
var testResponse = new QueryResult();
this.auditManagerMock.Setup(
m =>
m.QueryAsync(queryBatch.Query.WorkspaceId,
It.Is <QueryRequest>(r => r.ObjectType.ArtifactTypeID == auditArtifactTypeId && r.Condition == testCondition),
queryStart,
queryBatch.Size,
It.Is <AuditQueryOptions>(o => o.ReturnRawDetails == true)))
.ThrowsAsync(new Exception("TestException"));
// Act
// Assert
var exception =
Assert.ThrowsAsync <Exception>(() => this.dataGridService.ReadAuditsAsync(queryBatch, auditArtifactTypeId, choiceIds));
this.auditLogObjectManagerFactoryMock.VerifyAll();
this.auditManagerMock.VerifyAll();
this.dataGridConditionBuilderMock.VerifyAll();
this.dataGridResponseAuditMapperMock.VerifyAll();
}
public async Task <IList <Audit> > ReadAuditsAsync(AuditQueryBatch queryBatch, int auditArtifactTypeId, IList <int> actionChoiceIds)
{
return(await TimeSpan.FromSeconds(1).RetryCall(3, this.logger, async() =>
{
var queryStart = GetQueryStart(queryBatch);
var queryRequest = new QueryRequest
{
Condition = this.dataGridConditionBuilder.BuildActionTimeframeCondition(actionChoiceIds.ToArray(),
queryBatch.Query.StartTime, queryBatch.Query.EndTime),
Fields = new List <FieldRef>
{
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldAuditId
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldUserId
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldAuditArtifactId
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldDetails
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldTimeStamp
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldAction
},
new FieldRef {
Name = DataGridResourceConstants.DataGridFieldExecutionTime
}
},
ObjectType = new ObjectTypeRef()
{
ArtifactTypeID = auditArtifactTypeId
}
};
var auditQueryOptions = new AuditQueryOptions {
ReturnRawDetails = true
}; // Get Audit details
using (var auditManagerProxy = this.auditLogObjectManagerFactory.GetManager())
{
try
{
var result = await
auditManagerProxy.QueryAsync(
queryBatch.Query.WorkspaceId,
queryRequest,
queryStart,
queryBatch.Size,
auditQueryOptions
);
return this.dataGridResponseAuditMapper.ResponseToAudits(result, queryBatch.Query.WorkspaceId);
}
catch (Exception e)
{
if (e.Message.Contains("StatusCode: 404"))
{
this.logger.LogWarning(
$"Endpoint not found when reading audits {e.Message} {this.DataGridServiceDetails(queryBatch.Query)}, retrying...");
throw new RetryException(e);
}
else
{
throw this.DataGridServiceException(e, queryBatch.Query,
$"Failed to read audits Size: {queryBatch.Size}, Start: {queryBatch.Start} || queryStart: {queryStart}, QueryParam: {queryRequest.ToJson()}");
}
}
}
}));
}
