/// <inheritdoc/>
public async Task UpdateOrganisationAsync(
IWho who,
AuditEvent auditEvent,
IOrganisation organisation)
{
this.logger.ReportEntry(
who,
new { Organisation = organisation });
try
{
IAuditHeaderWithAuditDetails auditHeader = this.data.BeginTransaction(auditEvent, who);
await this.data
.UpdateOrganisationAsync(
who : who,
auditHeader : auditHeader,
organisation : organisation)
.ConfigureAwait(false);
await this.data.CommitTransactionAsync(auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction();
throw;
}
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task UpdateAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
ICompetition competition)
{
this.logger.LogTrace(
"ENTRY {Method}(who, host) {@Who} {@Competition}",
nameof(this.UpdateAsync),
who,
competition);
CompetitionDto dto = CompetitionDto.ToDto(competition);
CompetitionDto original = await this.context.FindAsync <CompetitionDto>(competition.Id)
.ConfigureAwait(false);
Audit.AuditUpdate(auditHeader, dto.Id, original, dto);
this.context.Entry(original).CurrentValues.SetValues(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
this.logger.LogTrace(
"EXIT {Method}(who) {@Who}",
nameof(this.UpdateAsync),
who);
}
/// <inheritdoc/>
public async Task UpdateMeetingAsync(
IWho who,
AuditEvent auditEvent,
IMeeting meeting)
{
this.logger.ReportEntry(
who,
new { Meeting = meeting });
try
{
IAuditHeaderWithAuditDetails auditHeader = this.data.BeginTransaction(auditEvent, who);
await this.data
.UpdateMeetingAsync(
who : who,
auditHeader : auditHeader,
meeting : meeting)
.ConfigureAwait(false);
await this.data.CommitTransactionAsync(auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction();
throw;
}
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task CreateAgendaItemRecursivelyAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IAgendaItem agendaItem)
{
AgendaItemDto dto = AgendaItemDto.ToDto(agendaItem);
this.context.AgendaItems.Add(dto);
Audit.AuditCreate(auditHeader, dto, dto.Id);
foreach (IAgendaItem child in agendaItem.ChildAgendaItems)
{
await this.CreateAgendaItemRecursivelyAsync(
who,
auditHeader,
child);
}
if (agendaItem.ParentId == null)
{
this.logger.Debug(
who,
"Saving changes",
new { AgendaItemId = agendaItem });
await this.context.SaveChangesAsync();
}
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task CreateCommitteeAsync(
IWho who,
AuditEvent auditEvent,
ICommittee committee)
{
this.logger.ReportEntry(
who,
new { Committee = committee });
try
{
IAuditHeaderWithAuditDetails auditHeader = this.data.BeginTransaction(auditEvent, who);
await this.data.CreateCommitteeAsync(
who : who,
auditHeader : auditHeader,
committee : committee)
.ConfigureAwait(false);
await this.data.CommitTransactionAsync(auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction();
throw;
}
this.logger.ReportExit(who);
}
public void Test_Passing_Valid_Values()
{
// ARRANGE
AuditHeaderDto auditHeaderDto = Create.AuditHeader();
AuditDetailDto auditDetailDto = Create.AuditDetail(auditHeaderDto);
auditHeaderDto.SetPrivatePropertyValue(
propName: nameof(AuditHeaderDto.AuditDetails),
value: new List <AuditDetailDto>
{
auditDetailDto
});
// ACT
IAuditHeaderWithAuditDetails auditHeader = auditHeaderDto.ToDomainWithAuditDetails();
// ASSERT
Assert.IsNotNull(auditHeader);
Assert.AreEqual(auditHeader.Id, auditHeader.Id);
Assert.AreEqual(auditHeader.AuditEvent, auditHeader.AuditEvent);
Assert.AreEqual(auditHeader.TimeStamp, auditHeader.TimeStamp);
Assert.AreEqual(auditHeader.Username, auditHeader.Username);
Assert.AreEqual(auditHeader.CorrelationId, auditHeader.CorrelationId);
Assert.IsNotNull(auditHeader.AuditDetails);
Assert.AreEqual(1, auditHeader.AuditDetails.Count);
}
public async Task Test_Commit_Writes_Record()
{
// ARRANGE
Mock <ILogger <VirtualBridgeData> > loggerMock =
MockFactory.CreateLoggerMock <VirtualBridgeData>();
Mock <ILogger <AuditHeaderRepository> > auditHeaderRepositoryLoggerMock =
MockFactory.CreateLoggerMock <AuditHeaderRepository>();
DbContextOptions <DataContext> dbOptions =
TestUtils.DbContextOptionsInMemory <TestBeginCommit>(
nameof(this.Test_Commit_Writes_Record));
await using DataContext dataContext = new DataContext(dbOptions);
AuditHeaderRepository auditHeaderRepository = new AuditHeaderRepository(
logger: auditHeaderRepositoryLoggerMock.Object,
dataContext: dataContext);
Mock <IOrganisationRepository> organisationRepositoryMock
= MockFactory.CreateRepositoryMock <IOrganisationRepository>();
VirtualBridgeData data = new VirtualBridgeData(
logger: loggerMock.Object,
dataContext: dataContext,
auditHeaderRepository: auditHeaderRepository,
organisationRepository: organisationRepositoryMock.Object);
IWho who = Create.Who();
// ACT
IAuditHeaderWithAuditDetails auditHeader = await data.BeginTransactionAsync(
who : who,
auditEvent : EAuditEvent.OrganisationMaintenance)
.ConfigureAwait(false);
auditHeader.AuditDetails.Add(
AuditDetail.CreateForCreate(
auditHeader: auditHeader,
tableName: "Organisation",
columnName: "Name",
recordId: Guid.NewGuid(),
newValue: "NewValue"));
await data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
// ASSERT
int auditHeadersCount = await dataContext.AuditHeaders.CountAsync()
.ConfigureAwait(false);
int auditDetailsCount = await dataContext.AuditDetails.CountAsync()
.ConfigureAwait(false);
Assert.AreEqual(1, auditHeadersCount);
Assert.AreEqual(1, auditDetailsCount);
}
/// <inheritdoc />
public Task CreateAsync(
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
if (who == null)
{
throw new ArgumentNullException(nameof(who));
}
if (organisation == null)
{
throw new ArgumentNullException(nameof(organisation));
}
return(CreateOrganisationInternalAsync());
async Task CreateOrganisationInternalAsync()
{
this.logger.LogTrace(
"ENTRY {Method}(who, organisation) {@Who} {@Organisation}",
nameof(this.CreateAsync),
who,
organisation);
try
{
IAuditHeaderWithAuditDetails auditHeader = await this.data.BeginTransactionAsync(
who, auditEvent)
.ConfigureAwait(false);
await this.data.Organisation.CreateAsync(
who : who,
auditHeader : auditHeader,
organisation : organisation)
.ConfigureAwait(false);
await this.data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction(who);
throw;
}
this.logger.LogTrace(
"EXIT {Method}(who) {@Who}",
nameof(this.CreateAsync),
who);
}
}
/// <summary>
/// Converts to DTO with AuditDetails.
/// </summary>
/// <param name="auditHeader">Audit Header.</param>
/// <returns>Audit Header DTO with Audit Details.</returns>
public static AuditHeaderDto ToDtoWithAuditDetails(
IAuditHeaderWithAuditDetails auditHeader)
{
if (auditHeader == null)
{
throw new ArgumentNullException(nameof(auditHeader));
}
return(new AuditHeaderDto(
id: auditHeader.Id,
auditEvent: auditHeader.AuditEvent,
timeStamp: auditHeader.TimeStamp,
username: auditHeader.Username,
correlationId: auditHeader.CorrelationId,
auditDetails: auditHeader.AuditDetails.Select(AuditDetailDto.ToDto).ToList()));
}
/// <inheritdoc/>
public async Task CreateMeetingAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IMeeting meeting)
{
this.logger.ReportEntry(
who,
new { Meeting = meeting });
MeetingDto dto = MeetingDto.ToDto(meeting);
this.context.Meetings.Add(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
Audit.AuditCreate(auditHeader, dto, dto.Id);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task CreateCommitteeAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
ICommittee committee)
{
this.logger.ReportEntry(
who,
new { Committee = committee });
CommitteeDto dto = CommitteeDto.ToDto(committee);
this.context.Committees.Add(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
Audit.AuditCreate(auditHeader, dto, dto.Id);
this.logger.ReportExit(who);
}
/// <inheritdoc />
public async Task CreateOrganisationAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IOrganisation organisation)
{
this.logger.ReportEntry(
who,
new { Organisation = organisation });
OrganisationDto dto = OrganisationDto.ToDto(organisation);
this.context.Organisations.Add(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
Audit.AuditCreate(auditHeader, dto, dto.Id);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task UpdateCommitteeAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
ICommittee committee)
{
this.logger.ReportEntry(
who,
new { Committee = committee });
CommitteeDto dto = CommitteeDto.ToDto(committee);
CommitteeDto original = await this.context.FindAsync <CommitteeDto>(committee.Id);
Audit.AuditUpdate(auditHeader, dto.Id, original, dto);
this.context.Entry(original).CurrentValues.SetValues(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task UpdateMeetingAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IMeeting meeting)
{
this.logger.ReportEntry(
who,
new { Meeting = meeting });
MeetingDto dto = MeetingDto.ToDto(meeting);
MeetingDto original = await this.context.FindAsync <MeetingDto>(meeting.Id);
Audit.AuditUpdate(auditHeader, dto.Id, original, dto);
this.context.Entry(original).CurrentValues.SetValues(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task UpdateAgendaItemAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IAgendaItem agendaItem)
{
this.logger.ReportEntry(
who,
new { AgendaItem = agendaItem });
AgendaItemDto dto = AgendaItemDto.ToDto(agendaItem);
AgendaItemDto original = await this.context.FindAsync <AgendaItemDto>(agendaItem.Id);
Audit.AuditUpdate(auditHeader, dto.Id, original, dto);
this.context.Entry(original).CurrentValues.SetValues(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task UpdateOrganisationAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
IOrganisation organisation)
{
this.logger.ReportEntry(
who,
new { Organisation = organisation });
OrganisationDto dto = OrganisationDto.ToDto(organisation);
OrganisationDto original = await this.context.FindAsync <OrganisationDto>(organisation.Id);
Audit.AuditUpdate(auditHeader, dto.Id, original, dto);
this.context.Entry(original).CurrentValues.SetValues(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
this.logger.ReportExit(who);
}
/// <inheritdoc/>
public async Task <IAgendaItem> CreateSkeletonAgendaAsync(
IWho who,
AuditEvent auditEvent,
Guid meetingId,
SkeletonAgendaType skeletonAgendaType)
{
this.logger.ReportEntry(
who,
new
{
AuditEvent = auditEvent,
MeetingId = meetingId,
SkeletonAgendaType = skeletonAgendaType
});
SkeletonAgendaFactory factory = new SkeletonAgendaFactory();
IAgendaItem agendaItem = factory.Create(meetingId, skeletonAgendaType);
try
{
IAuditHeaderWithAuditDetails auditHeader = this.data.BeginTransaction(auditEvent, who);
await this.data.CreateAgendaItemRecursivelyAsync(
who,
auditHeader,
agendaItem).ConfigureAwait(false);
await this.data.CommitTransactionAsync(auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
this.data.RollbackTransaction();
throw;
}
this.logger.ReportExit(
who,
new { AgendaItem = agendaItem });
return(agendaItem);
}
/// <summary>
/// Creates the organisation asynchronous.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="data">Data Layer.</param>
/// <param name="who">Who details.</param>
/// <param name="auditEvent">Audit event.</param>
/// <param name="organisation">Organisation to create.</param>
/// <returns>NOTHING.</returns>
internal static async Task CreateOrganisationAsync(
ILogger <VirtualBridgeService> logger,
IVirtualBridgeData data,
IWho who,
EAuditEvent auditEvent,
IOrganisation organisation)
{
logger.LogTrace(
"ENTRY {Method}(who, organisation) {@who} {@organisation}",
nameof(CreateOrganisationAsync),
who,
organisation);
try
{
IAuditHeaderWithAuditDetails auditHeader =
await data.BeginTransactionAsync(who, auditEvent)
.ConfigureAwait(false);
await data.Organisation.CreateAsync(
who : who,
auditHeader : auditHeader,
organisation : organisation)
.ConfigureAwait(false);
await data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
}
catch (Exception)
{
data.RollbackTransaction(who);
throw;
}
logger.LogTrace(
"EXIT {Method}(who) {@who}",
nameof(CreateOrganisationAsync),
who);
}
/// <inheritdoc />
public async Task CreateAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader)
{
this.logger.LogTrace(
"ENTRY {Method}(who, auditHeader) {@Who} {@AuditHeader}",
nameof(this.CreateAsync),
who,
auditHeader);
AuditHeaderDto auditHeaderDto =
AuditHeaderDto.ToDtoWithAuditDetails(auditHeader);
this.context.AuditHeaders.Add(auditHeaderDto);
await this.context.SaveChangesAsync()
.ConfigureAwait(false);
this.logger.LogTrace(
"EXIT {Method}(who) {@Who}",
nameof(this.CreateAsync),
who);
}
/// <inheritdoc/>
public async Task CreateAsync(
IWho who,
IAuditHeaderWithAuditDetails auditHeader,
ICompetition competition)
{
this.logger.LogTrace(
"ENTRY {Method}(who, organisation) {@Who} {@Competition}",
nameof(this.CreateAsync),
who,
competition);
CompetitionDto dto = CompetitionDto.ToDto(competition);
this.context.Competitions.Add(dto);
await this.context.SaveChangesAsync().ConfigureAwait(false);
Audit.AuditCreate(auditHeader, dto, dto.Id);
this.logger.LogTrace(
"EXIT {Method}(who) {@Who}",
nameof(this.CreateAsync),
who);
}
public async Task Test_Rollback_Does_Not_Thorw_Exception()
{
// ARRANGE
Mock <ILogger <VirtualBridgeData> > loggerMock =
MockFactory.CreateLoggerMock <VirtualBridgeData>();
DbContextOptions <DataContext> dbOptions =
TestUtils.DbContextOptionsInMemory <TestBeginCommit>(
nameof(this.Test_Rollback_Does_Not_Thorw_Exception));
await using DataContext dataContext = new DataContext(dbOptions);
Mock <IAuditHeaderRepository> auditHeaderRepositoryMock
= MockFactory.CreateRepositoryMock <IAuditHeaderRepository>();
Mock <IOrganisationRepository> organisationRepositoryMock
= MockFactory.CreateRepositoryMock <IOrganisationRepository>();
VirtualBridgeData data = new VirtualBridgeData(
logger: loggerMock.Object,
dataContext: dataContext,
auditHeaderRepository: auditHeaderRepositoryMock.Object,
organisationRepository: organisationRepositoryMock.Object);
IWho who = Create.Who();
// ACT
IAuditHeaderWithAuditDetails auditHeader = await data.BeginTransactionAsync(
who : who,
auditEvent : EAuditEvent.OrganisationMaintenance)
.ConfigureAwait(false);
data.RollbackTransaction(who);
await data.CommitTransactionAsync(who, auditHeader)
.ConfigureAwait(false);
// ASSERT
Assert.IsTrue(true);
}
