public void WithValidData(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period,
LifeCycleStageId lifeCycleStageLocalId)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, lifeCycleStageLocalId, lifeCycleStageType, period))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, lifeCycleStageLocalId, period))
.Then(publicServiceId,
new PeriodOfLifeCycleStageWasChanged(publicServiceId, lifeCycleStageLocalId, period)));
}
public void LifeCycleCannotHaveOverlappingPeriods(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStage1,
LifeCycleStageType lifeCycleStage2)
{
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, LifeCycleStageId.FromNumber(1), 1), new ValidTo(2020, LifeCycleStageId.FromNumber(1), 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2019, LifeCycleStageId.FromNumber(1), 1), new ValidTo(2021, LifeCycleStageId.FromNumber(1), 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStage1, period1))
.When(new AddStageToLifeCycle(publicServiceId, lifeCycleStage2, period2))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void CannotChangePeriodOfLifeCycleStageOnRemovedPublicService(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
ReasonForRemoval reasonForRemoval,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period,
LifeCycleStageId lifeCycleStageId)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, lifeCycleStageId, lifeCycleStageType, period),
new PublicServiceWasRemoved(publicServiceId, reasonForRemoval))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, lifeCycleStageId, period))
.Throws(new CannotPerformActionOnRemovedPublicService()));
}
public void LifeCycleOverlapsTakesChangesIntoAccount(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2018, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2022, 1, 1));
// Combining period2 with period3 will cause an overlap.
var period3 = new LifeCycleStagePeriod(new ValidFrom(2019, 1, 1), new ValidTo(2021, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new PeriodOfLifeCycleStageWasChanged(publicServiceId, LifeCycleStageId.FromNumber(1), period2))
.When(new AddStageToLifeCycle(publicServiceId, lifeCycleStageType, period3))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void LifeCycleCannotHaveOverlappingPeriods(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
// These two periods are ok because they don't overlap
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2021, 1, 1));
// Combining period1 with period3 will cause an overlap, however.
var period3 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), lifeCycleStageType, period2))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, LifeCycleStageId.FromNumber(2), period3))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void LifeCycleStageDoesNotOverlapWhenChangingItsOwnPeriod(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
// These two periods are ok because they don't overlap
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2021, 1, 1));
// Changing period1 to period3 for '1' will not cause an overlap
var period3 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2019, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), lifeCycleStageType, period2))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, LifeCycleStageId.FromNumber(1), period3))
.Then(publicServiceId,
new PeriodOfLifeCycleStageWasChanged(publicServiceId, LifeCycleStageId.FromNumber(1), period3)));
}
public PublicServiceListProjections(IClockProvider clockProvider)
{
When <Envelope <PublicServiceWasRegistered> >(async(context, message, ct) =>
{
var publicServiceListItem = new PublicServiceListItem
{
PublicServiceId = message.Message.PublicServiceId,
Name = message.Message.Name,
Removed = false
};
await context
.PublicServiceList
.AddAsync(publicServiceListItem, ct);
});
When <Envelope <PublicServiceWasRenamed> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.Name = message.Message.NewName;
});
When <Envelope <CompetentAuthorityWasAssigned> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.CompetentAuthorityCode = message.Message.CompetentAuthorityCode;
publicServiceListItem.CompetentAuthorityName = message.Message.CompetentAuthorityName;
});
When <Envelope <OrafinExportPropertyWasSet> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.ExportToOrafin = message.Message.ExportToOrafin;
});
When <Envelope <PublicServiceWasRemoved> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.Removed = true;
});
When <Envelope <StageWasAddedToLifeCycle> >(async(context, message, ct) =>
{
await AddLifeCycleStage(message, context, ct);
var period = new LifeCycleStagePeriod(
new ValidFrom(message.Message.From),
new ValidTo(message.Message.To));
if (!period.OverlapsWith(clockProvider.Today))
{
return;
}
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.CurrentLifeCycleStageType = message.Message.LifeCycleStageType;
publicServiceListItem.CurrentLifeCycleStageId = message.Message.LifeCycleStageId;
publicServiceListItem.CurrentLifeCycleStageEndsAt = message.Message.To;
});
When <Envelope <PeriodOfLifeCycleStageWasChanged> >(async(context, message, ct) =>
{
var publicServiceLifeCycleItem = await FindPublicServiceLifeCycleItemOrNull(
context,
message.Message.PublicServiceId,
message.Message.LifeCycleStageId,
ct);
publicServiceLifeCycleItem.From = message.Message.From;
publicServiceLifeCycleItem.To = message.Message.To;
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
var period = new LifeCycleStagePeriod(new ValidFrom(message.Message.From), new ValidTo(message.Message.To));
if (period.OverlapsWith(clockProvider.Today))
{
publicServiceListItem.CurrentLifeCycleStageId = message.Message.LifeCycleStageId;
publicServiceListItem.CurrentLifeCycleStageType = publicServiceLifeCycleItem.LifeCycleStageType;
publicServiceListItem.CurrentLifeCycleStageEndsAt = message.Message.To;
}
else if (publicServiceListItem.CurrentLifeCycleStageId == message.Message.LifeCycleStageId &&
!period.OverlapsWith(clockProvider.Today))
{
publicServiceListItem.CurrentLifeCycleStageId = null;
publicServiceListItem.CurrentLifeCycleStageType = null;
publicServiceListItem.CurrentLifeCycleStageEndsAt = null;
}
});
When <Envelope <LifeCycleStageWasRemoved> >(async(context, message, ct) =>
{
var publicServiceLifeCycleItem = await FindPublicServiceLifeCycleItemOrNull(
context,
message.Message.PublicServiceId,
message.Message.LifeCycleStageId,
ct);
// TODO: does this work properly in catch up mode? Implementing soft-delete might solve this indirectly
context.LifeCycleStagesForPublicServiceList.Remove(publicServiceLifeCycleItem);
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
if (publicServiceListItem.CurrentLifeCycleStageId == publicServiceLifeCycleItem.LifeCycleStageId)
{
publicServiceListItem.CurrentLifeCycleStageId = null;
publicServiceListItem.CurrentLifeCycleStageType = null;
publicServiceListItem.CurrentLifeCycleStageEndsAt = null;
}
});
When <Envelope <IpdcCodeWasSet> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.IpdcCode = message.Message.IpdcCode;
});
When <Envelope <LegislativeDocumentIdWasSet> >(async(context, message, ct) =>
{
var publicServiceListItem = await FindPublicService(
context,
message.Message.PublicServiceId,
ct);
publicServiceListItem.LegislativeDocumentId = message.Message.LegislativeDocumentId;
});
When <Envelope <ClockHasTicked> >(async(context, message, ct) =>
{
var date = LocalDate.FromDateTime(message.Message.DateTime);
var dateAsInt = date.ToInt();
// TODO: This needs to query on both local and db
foreach (var publicServiceListItem in context.PublicServiceList.Where(item => item.CurrentLifeCycleStageEndsAtAsInt != null && item.CurrentLifeCycleStageEndsAtAsInt < dateAsInt))
{
await UpdateCurrentLifeCycleStage(context, publicServiceListItem, date, ct);
}
});
}
private void When(PeriodOfLifeCycleStageWasChanged @event)
{
var lifeCycleStagePeriod = new LifeCycleStagePeriod(new ValidFrom(@event.From), new ValidTo(@event.To));
_lifeCycleStagePeriods[@event.LifeCycleStageId] = lifeCycleStagePeriod;
}
public void ChangePeriodOfLifeCycleStage(LifeCycleStageId lifeCycleStageId, LifeCycleStagePeriod period)
{
EnsureNotRemoved();
_lifeCycle.ChangePeriod(lifeCycleStageId, period);
}
public void AddStageToLifeCycle(LifeCycleStageType lifeCycleStageType, LifeCycleStagePeriod period)
{
EnsureNotRemoved();
_lifeCycle.AddStage(lifeCycleStageType, period);
}