public void TestWithValidValues()
{
// ARRANGE
IAuditHeader paramAuditHeader = Create.AuditHeader();
const string paramTableName = "Organisation";
const string paramColumnName = "Id";
Guid paramRecordId = Guid.NewGuid();
const string paramNewValue = "New Value";
const string paramOldValue = "Old Value";
// ACT
IAuditDetail auditDetail = AuditDetail.CreateForUpdate(
paramAuditHeader,
paramTableName,
paramColumnName,
paramRecordId,
paramOldValue,
paramNewValue);
// ASSERT
Assert.IsNotNull(auditDetail);
Assert.AreNotEqual(paramRecordId, auditDetail.Id);
Assert.AreSame(paramAuditHeader, auditDetail.AuditHeader);
Assert.AreEqual(paramTableName, auditDetail.TableName);
Assert.AreEqual(paramColumnName, auditDetail.ColumnName);
Assert.AreEqual(paramRecordId, auditDetail.RecordId);
Assert.AreEqual(paramOldValue, auditDetail.OldValue);
Assert.AreEqual(paramNewValue, auditDetail.NewValue);
Assert.AreEqual(EDatabaseAction.Update, auditDetail.DatabaseAction);
}
/// <summary>
/// Audits the update.
/// </summary>
/// <param name="auditHeader">Audit Header.</param>
/// <param name="recordId">Record Id.</param>
/// <param name="oldObject">Old Value.</param>
/// <param name="newObject">New Value.</param>
internal static void AuditUpdate(
IAuditHeaderWithAuditDetails?auditHeader,
Guid recordId,
BaseDto oldObject,
BaseDto newObject)
{
if (auditHeader == null)
{
return;
}
Type type = newObject.GetType();
PropertyDescriptorCollection propertyDescriptors = TypeDescriptor.GetProperties(type);
foreach (PropertyInfo propertyInfo in type.GetProperties().OrderBy(p => p.MetadataToken))
{
// Skip if not auditable field
if (!PropertyUtilities.IsAuditableColumn(propertyDescriptors, propertyInfo))
{
continue;
}
// Get old and new values
string oldValue = propertyInfo.GetValueAsString(oldObject);
string newValue = propertyInfo.GetValueAsString(newObject);
// Skip if value unchanged
if (CompareNullable.AreEqual(oldValue, newValue))
{
continue;
}
PropertyDescriptor propertyDescriptor = propertyDescriptors[propertyInfo.Name];
TableAttribute?tableAttribute =
(TableAttribute?)propertyDescriptor.Attributes[typeof(TableAttribute)];
string tableName = tableAttribute == null
? type.Name
: tableAttribute.Name;
ColumnAttribute?columnAttribute =
(ColumnAttribute?)propertyDescriptor.Attributes[typeof(ColumnAttribute)];
string columnName = columnAttribute == null
? propertyInfo.Name
: columnAttribute.Name;
IAuditDetail auditDetail = AuditDetail.CreateForUpdate(
auditHeader: auditHeader,
tableName: tableName,
columnName: columnName,
recordId: recordId,
oldValue: oldValue,
newValue: newValue);
auditHeader.AuditDetails.Add(auditDetail);
}
}
/// <summary>
/// Audits the create.
/// </summary>
/// <param name="auditHeader">Audit Header.</param>
/// <param name="newObject">New value.</param>
/// <param name="recordId">Record Id.</param>
internal static void AuditCreate(
IAuditHeaderWithAuditDetails?auditHeader,
BaseDto newObject,
Guid recordId)
{
if (auditHeader == null)
{
return;
}
Type type = newObject.GetType();
PropertyDescriptorCollection propertyDescriptors = TypeDescriptor.GetProperties(type);
foreach (PropertyInfo propertyInfo in type.GetProperties().OrderBy(p => p.MetadataToken))
{
if (!PropertyUtilities.
IsAuditableColumn(propertyDescriptors, propertyInfo))
{
continue;
}
string newValue = propertyInfo.GetValueAsString(newObject);
PropertyDescriptor propertyDescriptor = propertyDescriptors[propertyInfo.Name];
TableAttribute?tableAttribute =
(TableAttribute?)propertyDescriptor.Attributes[typeof(TableAttribute)];
string tableName = tableAttribute == null
? type.Name
: tableAttribute.Name;
ColumnAttribute?columnAttribute =
(ColumnAttribute?)propertyDescriptor.Attributes[typeof(ColumnAttribute)];
string columnName = columnAttribute == null
? propertyInfo.Name
: columnAttribute.Name;
IAuditDetail auditDetail = AuditDetail.CreateForCreate(
auditHeader: auditHeader,
tableName: tableName,
columnName: columnName,
recordId: recordId,
newValue: newValue);
auditHeader.AuditDetails.Add(auditDetail);
}
}
public static AuditDetailDto ToDto(IAuditDetail auditDetail)
{
if (auditDetail == null)
{
throw new ArgumentNullException(nameof(auditDetail));
}
return new AuditDetailDto(
id: auditDetail.Id,
auditHeaderId: auditDetail.AuditHeader.Id,
tableName: auditDetail.TableName,
columnName: auditDetail.ColumnName,
recordId: auditDetail.RecordId,
oldValue: auditDetail.OldValue,
newValue: auditDetail.NewValue,
databaseAction: auditDetail.DatabaseAction);
}
/// <summary>
/// Audits the create.
/// </summary>
/// <param name="auditHeader">Audit Header.</param>
/// <param name="newObject">New value.</param>
/// <param name="recordId">Record Id.</param>
internal static void AuditCreate(
IAuditHeaderWithAuditDetails?auditHeader,
BaseDto newObject,
Guid recordId)
{
if (auditHeader == null)
{
return;
}
Type type = newObject.GetType();
string tableName = type.Name; // TODO:[SJW] Assumed table name matches type name
PropertyDescriptorCollection propertyDescriptors = TypeDescriptor.GetProperties(type);
foreach (PropertyInfo propertyInfo in type.GetProperties().OrderBy(p => p.MetadataToken))
{
if (!PropertyUtilities.IsAuditableColumn(propertyDescriptors, propertyInfo))
{
continue;
}
string newValue = propertyInfo.GetGetMethod().Invoke(newObject, null) == null
? string.Empty
: propertyInfo.GetGetMethod().Invoke(newObject, null).ToString();
PropertyDescriptor propertyDescriptor = propertyDescriptors[propertyInfo.Name];
ColumnAttribute? columnAttribute =
(ColumnAttribute?)propertyDescriptor.Attributes[typeof(ColumnAttribute)];
string columnName = columnAttribute == null
? propertyInfo.Name
: columnAttribute.Name ?? string.Empty;
IAuditDetail auditDetail = AuditDetail.CreateForCreate(
auditHeader: auditHeader,
tableName: tableName,
columnName: columnName,
recordId: recordId,
newValue: newValue);
auditHeader.AuditDetails.Add(auditDetail);
}
}
public async Task Test_With_Valid_Values()
{
// ARRANGE
Mock <ILogger <AuditHeaderRepository> > loggerMock =
TestUtilities.MockFactory.CreateLoggerMock <AuditHeaderRepository>();
DbContextOptions <DataContext> dbOptions =
TestUtils.DbContextOptionsInMemory <CreateAsyncTests>(nameof(this.Test_With_Valid_Values));
await using DataContext dataContext = new DataContext(dbOptions);
IAuditHeaderRepository repository = new AuditHeaderRepository(
loggerMock.Object,
dataContext);
IAuditHeaderWithAuditDetails auditHeader = new AuditHeaderWithAuditDetails(
auditEvent: EAuditEvent.OrganisationMaintenance,
username: "******",
correlationId: Guid.NewGuid());
IAuditDetail auditDetail = AuditDetail.CreateForUpdate(
auditHeader: auditHeader,
tableName: "TableName",
columnName: "ColumnName",
recordId: Guid.NewGuid(),
oldValue: "Old Value",
newValue: "New Value");
auditHeader.AuditDetails.Add(auditDetail);
IWho who = new Who(
"TestController",
"Action",
"/TestController/Action",
string.Empty);
// ACT
await repository.CreateAsync(who, auditHeader)
.ConfigureAwait(false);
// ASSERT
Assert.AreEqual(1, await dataContext.AuditHeaders.CountAsync().ConfigureAwait(false));
Assert.AreEqual(1, await dataContext.AuditDetails.CountAsync().ConfigureAwait(false));
}
public void Test_Passing_Valid_Values()
{
// ARRANGE
AuditHeaderDto auditHeaderDto = Create.AuditHeader();
AuditDetailDto auditDetailDto = Create.AuditDetail(auditHeaderDto);
// ACT
IAuditDetail auditDetail = auditDetailDto.ToDomain();
// ASSERT
Assert.IsNotNull(auditDetail);
Assert.AreEqual(auditDetailDto.Id, auditDetail.Id);
Assert.AreEqual(auditDetailDto.AuditHeaderId, auditDetail.AuditHeader.Id);
Assert.AreEqual(auditDetailDto.TableName, auditDetail.TableName);
Assert.AreEqual(auditDetailDto.ColumnName, auditDetail.ColumnName);
Assert.AreEqual(auditDetailDto.RecordId, auditDetail.RecordId);
Assert.AreEqual(auditDetailDto.OldValue, auditDetail.OldValue);
Assert.AreEqual(auditDetailDto.NewValue, auditDetail.NewValue);
Assert.AreEqual(auditDetailDto.DatabaseAction, auditDetail.DatabaseAction);
}
