public ProcessedEventFilter(IProcessedEventRepository processedEventRepository,
IConsumerProvider consumerProvider, ISystemTimeProvider systemTimeProvider)
{
_processedEventRepository = processedEventRepository;
_consumerProvider = consumerProvider;
_systemTimeProvider = systemTimeProvider;
}
public void ShouldReturnExpectedResult(ContactData seller, ContactData buyer, IReadOnlyCollection <OrderItem> items,
ISystemTimeProvider systemTimeProvider, ISingleCurrencyPolicy singleCurrencyPolicy, ISingleItemsCurrencyPolicy singleItemsCurrencyPolicy, bool expected, string because)
{
var orderResult = Order.Create(seller, buyer, items, systemTimeProvider, singleCurrencyPolicy, singleItemsCurrencyPolicy);
orderResult.IsSuccess.Should().Be(expected, because);
}
public static Task <Result <Order> > CreateWithDefaultSellerAsync(ContactData buyer, IReadOnlyCollection <OrderItem> items,
ISystemTimeProvider systemTimeProvider, ISingleCurrencyPolicy singleCurrencyPolicy, ISingleItemsCurrencyPolicy singleItemsCurrencyPolicy,
IOrderRepository orderRepository)
{
return(Create(Company.DefaultSeller, buyer, items, systemTimeProvider, singleCurrencyPolicy,
singleItemsCurrencyPolicy)
.OnSuccess(async order => await orderRepository.SaveAsync(order)));
}
private Registration(ExternalRegistrationId externalId, ExamId examId, OrderId orderId, Candidate candidate,
ISystemTimeProvider systemTimeProvider) : this(systemTimeProvider)
{
ExternalId = externalId;
Status = RegistrationStatus.New;
Candidate = candidate;
ExamId = examId;
OrderId = orderId;
}
public static string FormatMessage(this string message, ISystemTimeProvider systemTypeProvider, Type typeToLog, params object[] values)
{
return(string.Format(
CultureInfo.InvariantCulture,
MessageFormat,
systemTypeProvider.UtcNow,
Thread.CurrentThread.GetName(),
typeToLog.FullName,
string.Format(CultureInfo.InvariantCulture, message, values)));
}
public static Result <Order> Create(ContactData seller, ContactData buyer, IReadOnlyCollection <OrderItem> items,
ISystemTimeProvider systemTimeProvider, ISingleCurrencyPolicy singleCurrencyPolicy, ISingleItemsCurrencyPolicy singleItemsCurrencyPolicy)
{
var creationDateResult = UtcDateTime.Create(systemTimeProvider.UtcNow);
var summaryResult = CreateSummary(items, singleItemsCurrencyPolicy, singleCurrencyPolicy);
return(Result.Combine(creationDateResult, summaryResult)
.OnSuccess(() => new Order(creationDateResult.Value, seller, buyer, items, summaryResult.Value,
systemTimeProvider)));
}
public static string FormatMessage(this string message, ISystemTimeProvider systemTypeProvider, Type typeToLog, params object[] values)
{
return string.Format(
CultureInfo.InvariantCulture,
MessageFormat,
systemTypeProvider.UtcNow,
Thread.CurrentThread.GetName(),
typeToLog.FullName,
string.Format(CultureInfo.InvariantCulture, message, values));
}
private Order(UtcDateTime creationDateTime, ContactData seller, ContactData buyer,
IReadOnlyCollection <OrderItem> items, Price summary, ISystemTimeProvider systemTimeProvider)
: this(systemTimeProvider)
{
Status = OrderStatus.AwaitingForPayment;
CreationDateTime = creationDateTime;
Seller = seller;
Buyer = buyer;
Items = items;
Summary = summary;
}
public OptimisticEventStream(
string bucketId,
string streamId,
ICommitEvents persistence,
ISystemTimeProvider systemTypeProvider
)
{
BucketId = bucketId;
StreamId = streamId;
_persistence = persistence;
_systemTypeProvider = systemTypeProvider;
}
public OptimisticEventStream(
string bucketId,
string streamId,
ICommitEvents persistence,
ISystemTimeProvider systemTypeProvider
)
{
BucketId = bucketId;
StreamId = streamId;
_persistence = persistence;
_systemTypeProvider = systemTypeProvider;
}
public CreateRegistrationCommandHandler(IRegistrationRepository registrationRepository,
ISystemTimeProvider systemTimeProvider, ISingleCurrencyPolicy singleCurrencyPolicy,
ISingleItemsCurrencyPolicy singleItemsCurrencyPolicy, IExamPricingProvider examPricingProvider,
IOrderRepository orderRepository, IExamRepository examRepository)
{
_registrationRepository = registrationRepository;
_systemTimeProvider = systemTimeProvider;
_singleCurrencyPolicy = singleCurrencyPolicy;
_singleItemsCurrencyPolicy = singleItemsCurrencyPolicy;
_examPricingProvider = examPricingProvider;
_orderRepository = orderRepository;
_examRepository = examRepository;
}
public static Result <CreateRegistrationCommand> Create(CreateRegistrationRequest request,
ISystemTimeProvider systemTimeProvider, IExamExistenceValidator examExistenceValidator)
{
var candidateResult = DateOfBirth.Create(request.DateOfBirth, systemTimeProvider)
.OnSuccess(dateOfBirth => Candidate.Create(request.FirstName, request.LastName, dateOfBirth));
var examResult = ExamId.Create(request.ExamId, examExistenceValidator);
var buyerResult = ContactData.Create(request.Buyer?.Name, request.Buyer?.StreetAddress, request.Buyer?.City,
request.Buyer?.ZipCode);
return(Result.Combine(candidateResult, examResult, buyerResult)
.OnSuccess(() =>
new CreateRegistrationCommand(candidateResult.Value, examResult.Value, buyerResult.Value)));
}
private Exam(SubjectId subjectId, LocationId locationId, UtcDateTime examDateTime, Capacity capacity,
UtcDate registrationStartDate, UtcDate registrationEndDate, ISystemTimeProvider systemTimeProvider)
: this(systemTimeProvider)
{
LocationId = locationId;
Capacity = capacity;
Booked = Booked.Zero;
SubjectId = subjectId;
RegistrationStartDate = registrationStartDate;
RegistrationEndDate = registrationEndDate;
ExamDateTime = examDateTime;
Status = ExamStatus.Planned;
}
public static Task <Result <Exam> > CreateAsync(SubjectId subjectId, LocationId locationId, UtcDateTime examDateTime,
Capacity capacity, UtcDate registrationStartDate, UtcDate registrationEndDate,
ISystemTimeProvider systemTimeProvider, IExamRepository examRepository)
{
return(Result.Create(() => systemTimeProvider.UtcNow < registrationStartDate.Value,
ExamCreationErrors.RegistrationStartDateHasToBeInTheFuture.Build())
.AndEnsure(() => registrationStartDate.Value < registrationEndDate.Value,
ExamCreationErrors.RegistrationEndDateHasToBeAfterRegistrationStartDate.Build())
.AndEnsure(() => registrationEndDate.Value < examDateTime.Value.Date,
ExamCreationErrors.RegistrationEndDateHasToBeBeforeExamDate.Build())
.OnSuccess(() => new Exam(subjectId, locationId, examDateTime, capacity, registrationStartDate,
registrationEndDate, systemTimeProvider))
.OnSuccess(examRepository.SaveAsync)
.OnSuccess(exam => exam.RaiseEvent(new ExamPlanned(exam.Id, systemTimeProvider.UtcNow))));
}
public OptimisticEventStore(
IPersistStreams persistence,
IEnumerable <IPipelineHook> pipelineHooks,
ISystemTimeProvider systemTimeProvider
)
{
if (persistence == null)
{
throw new ArgumentNullException("persistence");
}
_pipelineHooks = pipelineHooks ?? new IPipelineHook[0];
_persistence = new PipelineHooksAwarePersistanceDecorator(persistence, _pipelineHooks);
_systemTimeProvider = systemTimeProvider;
}
public OptimisticEventStore(
IPersistStreams persistence,
IEnumerable<IPipelineHook> pipelineHooks,
ISystemTimeProvider systemTimeProvider
)
{
if (persistence == null)
{
throw new ArgumentNullException("persistence");
}
_pipelineHooks = pipelineHooks ?? new IPipelineHook[0];
_persistence = new PipelineHooksAwarePersistanceDecorator(persistence, _pipelineHooks);
_systemTimeProvider = systemTimeProvider;
}
public static CommitAttempt BuildCommit(this string streamId, ISystemTimeProvider systemTimeProvider)
{
const int streamRevision = 2;
const int commitSequence = 2;
Guid commitId = Guid.NewGuid();
var headers = new Dictionary <string, object> {
{ "Key", "Value" }, { "Key2", (long)1234 }, { "Key3", null }
};
var events = new[]
{
new EventMessage
{
Headers = { { "MsgKey1", TimeSpan.MinValue }, { "MsgKey2", Guid.NewGuid() }, { "MsgKey3", 1.1M }, { "MsgKey4", (ushort)1 } },
Body = "some value"
},
new EventMessage
{
Headers = { { "MsgKey1", new Uri("http://www.google.com/") }, { "MsgKey4", "some header" } },
Body = new[] { "message body" }
}
};
return(new CommitAttempt(streamId, streamRevision, commitId, commitSequence, systemTimeProvider.UtcNow, headers, events.ToList()));
}
public OutputWindowLogger(Type typeToLog, ISystemTimeProvider systemTypeProvider)
{
_typeToLog = typeToLog;
_systemTypeProvider = systemTypeProvider ?? new DefaultSystemTimeProvider();
}
protected AggregateRoot(ISystemTimeProvider systemTimeProvider)
{
SystemTimeProvider = systemTimeProvider;
StateMachine = new StateMachine <TStates, TActions>(() => Status, status => Status = status);
ConfigureStates();
}
public OutputWindowLogger(Type typeToLog, ISystemTimeProvider systemTypeProvider)
{
_typeToLog = typeToLog;
_systemTypeProvider = systemTypeProvider ?? new DefaultSystemTimeProvider();
}
public static Result <DateOfBirth> Create(DateTime dateOfBirth, ISystemTimeProvider systemTimeProvider)
{
return(Result.Create(dateOfBirth < systemTimeProvider.UtcNow, DateOfBirthErrors.ShouldBeInThePast.Build())
.OnSuccess(() => new DateOfBirth(dateOfBirth)));
}
private Exam(ISystemTimeProvider systemTimeProvider) : base(systemTimeProvider)
{
}
public CreateExamCommandHandler(IExamRepository examRepository, ISystemTimeProvider systemTimeProvider)
{
_examRepository = examRepository;
_systemTimeProvider = systemTimeProvider;
}
public static async Task <Result <Registration> > CreateAsync(ExternalRegistrationId externalRegistrationId,
ExamId examId, OrderId orderId, Candidate candidate, ISystemTimeProvider systemTimeProvider,
IRegistrationRepository registrationRepository)
{
return(await Result.Create(candidate != null, RegistrationErrors.CandidateCannotBeEmpty.Build())
.OnSuccess(() =>
new Registration(externalRegistrationId, examId, orderId, candidate, systemTimeProvider))
.OnSuccess(async registration => await registrationRepository.SaveAsync(registration))
.OnSuccess(registration => registration.RaiseEvent(new RegistrationCreated(registration.Id,
registration.ExternalId, candidate, systemTimeProvider.UtcNow))));
}
public ConsoleWindowLogger(Type typeToLog, ISystemTimeProvider systemTypeProvider)
{
_systemTypeProvider = systemTypeProvider ?? new DefaultSystemTimeProvider();
_typeToLog = typeToLog;
}
public ConsoleWindowLogger(Type typeToLog, ISystemTimeProvider systemTypeProvider)
{
_systemTypeProvider = systemTypeProvider ?? new DefaultSystemTimeProvider();
_typeToLog = typeToLog;
}
private Registration(ISystemTimeProvider systemTimeProvider) : base(systemTimeProvider)
{
}
public static ProcessedEventEntity Create(Guid messageId, string consumer,
ISystemTimeProvider systemTimeProvider)
{
return(new ProcessedEventEntity(messageId, consumer, systemTimeProvider.UtcNow));
}
public string GetLocalTime([FromServices] ISystemTimeProvider provider) => $"{provider.GetCurrentTime(DateTimeKind.Local)}[{DateTime.Now}]";
public string GetUtcTime([FromServices] ISystemTimeProvider provider) => $"{provider.GetCurrentTime(DateTimeKind.Utc)}[{DateTime.UtcNow}]";
private Order(ISystemTimeProvider systemTimeProvider) : base(systemTimeProvider)
{
}
public RegistrationsController(IMediator mediator, IExamExistenceValidator examExistenceValidator,
ISystemTimeProvider systemTimeProvider) : base(mediator)
{
_examExistenceValidator = examExistenceValidator;
_systemTimeProvider = systemTimeProvider;
}
