public async Task DataGrid_EndToEnd_ReadTotal()
{
var workspaceId = Config.WorkSpaceId;
var auditQuery = new AuditQuery
{
ActionTypes = new List <AuditActionId> {
AuditActionId.DocumentQuery
},
StartTime = DateTime.MinValue,
EndTime = DateTime.UtcNow,
WorkspaceId = workspaceId
};
// However we grab this for testing...
var apiClientHelper = new ApiClientHelper();
var auditLogObjectManager = apiClientHelper.GetKeplerServiceReference <IExternalAuditLogObjectManager>();
//using (var auditLogObjectManager = TestUtilities.GetServicesManager().CreateProxy<IExternalAuditLogObjectManager>(ExecutionIdentity.System))
// 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.ReadTotalAuditsForHourAsync(workspaceId, auditQuery.StartTime, auditQuery.EndTime,
auditQuery.ActionTypes);
Assert.Pass($"Test Passed - ResultCount {result}");
}
public async Task <Unit> Handle(CreateAuditQuery query, CancellationToken cancellationToken)
{
var auditQuery = AuditQuery.Create(query, _authentificationContext, _auditSerializer);
_dbContext.AuditQueries.Add(auditQuery);
await _dbContext.SaveChangesAsync();
return(Unit.Value);
}
public IActionResult Index()
{
var query = new AuditQuery();
query.AuditState = AuditState.InProgress;
var result = _auditQuery.Handle(query);
return(View(result));
}
public async Task <long> ReadTotalAuditsForHourAsync(AuditQuery query, int auditArtifactTypeId, IList <int> actionChoiceIds, int userGroupById)
{
var pivotSettings = new PivotSettings()
{
ArtifactTypeID = auditArtifactTypeId,
GroupBy = new global::Relativity.Services.Field.FieldRef(userGroupById),
ObjectSetQuery = new global::Relativity.Services.Query()
{
Condition =
this.dataGridConditionBuilder.BuildActionTimeframeCondition(actionChoiceIds.ToArray(), query.StartTime,
query.EndTime)
}
};
using (var auditManagerProxy = this.auditLogObjectManagerFactory.GetManager())
{
try
{
var result = await
auditManagerProxy.ExecuteAsync(
query.WorkspaceId,
pivotSettings,
CancellationToken.None,
new NonCapturingProgress <string>());
if (!result.Success)
{
throw new Exception(
$"Read TotalAudits returned unsuccessful with message: {result.Message}");
}
try
{
if (result.Results.Columns.Contains(DataGridResourceConstants.DataGridGrandTotal))
{
return(result.Results.AsEnumerable().Sum(x => Convert.ToInt64(x[DataGridResourceConstants.DataGridGrandTotal])));
}
// Column doesn't exist, no values returned
await this.logger.LogVerboseAsync($"No audit totals returned... {result.Results.ToJson()} -- {result.Results.Columns[DataGridResourceConstants.DataGridGrandTotal]} -- WorkspaceId {query.WorkspaceId}, StartTime {query.StartTime}, EndTime {query.EndTime}", Names.LogCategory.DataGrid);
return(0);
}
catch (Exception e)
{
throw new Exception($"Failed to parse result.Results {result.Results.ToJson()} -- {result.Results.Columns[DataGridResourceConstants.DataGridGrandTotal]}", e);
}
}
catch (Exception e)
{
throw this.DataGridServiceException(e, query, $"Failed to read TotalAudits, PivotSettings: {pivotSettings.ToJson()}");
}
}
}
public async Task ReadTotalAuditExecutionTimeForHourAsync()
{
// Arrange
var query = new AuditQuery
{
};
var auditArtifactTypeId = 2;
var choiceIds = new[] { 1, 2 };
var userGroupById = 3;
var result = await this.dataGridService.ReadTotalAuditExecutionTimeForHourAsync(query, auditArtifactTypeId, choiceIds, userGroupById);
}
public async Task ReadUniqueUsersForHourAuditsAsync()
{
// Arrange
var query = new AuditQuery
{
};
var auditArtifactTypeId = 2;
var choiceIds = new[] { 1, 2 };
var userGroupById = 3;
var testCondition = "TEST";
this.dataGridConditionBuilderMock.Setup(
m => m.BuildActionTimeframeCondition(choiceIds, query.StartTime, query.EndTime))
.Returns(testCondition);
var users = new[] { 12, 34, 56 };
var expectedResult = new PivotResultSet
{
Results = new DataTable("TestTable")
{
Columns = { new DataColumn(DataGridResourceConstants.DataGridUserName, typeof(string)) },
},
Success = true
};
users.ForEach(u =>
{
var row = expectedResult.Results.NewRow();
row[DataGridResourceConstants.DataGridUserName] = u.ToString();
expectedResult.Results.Rows.Add(row);
});
this.auditManagerMock.Setup(m => m.ExecuteAsync(
query.WorkspaceId,
It.Is <PivotSettings>(s =>
s.ArtifactTypeID == auditArtifactTypeId &&
s.GroupBy.ArtifactID == userGroupById &&
s.ObjectSetQuery.Condition == testCondition),
It.IsAny <CancellationToken>(),
It.IsAny <IProgress <string> >()))
.ReturnsAsync(expectedResult);
var result = await this.dataGridService.ReadUniqueUsersForHourAuditsAsync(query, auditArtifactTypeId, choiceIds, userGroupById);
// Assert
Assert.That(result, Is.EquivalentTo(users));
}
public async Task <long> ReadTotalAuditsForHourAsync(int workspaceId, DateTime startHour, DateTime endHour, IList <AuditActionId> actionTypes)
{
// 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);
var userGroupById = this.artifactRepository.ReadGroupByArtifactId(workspaceId, DataGridGroupByEnum.User);
await Task.WhenAll(auditArtifactTypeId, choiceIds, userGroupById);
var query = new AuditQuery
{
WorkspaceId = workspaceId,
ActionTypes = actionTypes,
StartTime = startHour,
EndTime = endHour
};
return(await this.dataGridService.ReadTotalAuditsForHourAsync(query, auditArtifactTypeId.Result, choiceIds.Result, userGroupById.Result));
}
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 async Task <IEnumerable <AuditResult> > GetResults(IEnumerable <IPackageInfo> packages)
{
var packagesCoordinates = packages.Select(pkg => $"pkg:nuget/{pkg.Name}@{pkg.Version}");
var query = new AuditQuery
{
Coordinates = packagesCoordinates
};
var request = new RestRequest(Method.POST);
request.AddJsonBody(JsonConvert.SerializeObject(query));
var response = await _restClient.ExecuteAsync(request);
if (!response.IsSuccessful)
{
throw new InvalidOperationException("Request failed with code: " + response.StatusCode);
}
return(JsonConvert.DeserializeObject <IEnumerable <AuditResult> >(response.Content));
}
private string DataGridServiceDetails(AuditQuery query)
{
return($"AuditQuery params: {query.ToJson()}");
}
private Exception DataGridServiceException(Exception innerException, AuditQuery query, string additionalDetails)
{
additionalDetails = string.IsNullOrEmpty(additionalDetails) ? "None" : additionalDetails;
return(new Exception($"DataGridService call failed for {this.DataGridServiceDetails(query)} -- Additional details: {additionalDetails}", innerException));
}
public Task <long> ReadTotalAuditExecutionTimeForHourAsync(AuditQuery query, int auditArtifactTypeId, IList <int> actionChoiceIds, int userGroupById)
{
throw new NotImplementedException("TotalAuditExecutionTime not supported on Data Grid APIs");
}
public ActionResult History(SortAudit sort, SortOrder order, int? page, int? id)
{
var query = new AuditQuery<User>(sort, order, page, id);
var audits = this.AuditService.GetPaged(query.Specification);
var audit = audits.FirstOrDefault();
var privilege = new AuditPrivilege();
return privilege.CanView(audit) ? base.View(Views.History, audits) : NotAuthorized();
}
