public async Task When(CustomerCreated e) { var customer = _mapper.Map <CustomerEntity>(e); _repository.Add(customer); await _repository.SaveChangesAsync(); }
public void REGISTER_PROJECTIONS() { var appendStore = new FileAppendOnlyStore(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Store\"); var eventStore = new EventStore(appendStore); var publisher = new DomainEventPublisher(eventStore, 0, 500); var store = new FileDocumentReaderWriter <CustomerId, CustomerTransactions>(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Store\", new ViewStrategy(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Views\")); IDocumentWriter <CustomerId, CustomerTransactions> writer = store; var projection = new CustomerTransactionsProjection(writer); publisher.RegisterProjection(projection); var id = new CustomerId(2); var @event = new CustomerCreated { Id = id, Name = "Microsoft", Currency = Currency.Eur }; IList <IEvent> Changes = new List <IEvent>(); Changes.Add(@event); eventStore.AppendToStream(id, 0, Changes); publisher.ProcessNewEvents(); }
public void Apply(CustomerCreated @event) { Id = @event.Id; _name = @event.Name; _emailAddress = new EmailAddress(@event.EmailAddress); }
private void When(CustomerCreated e) { this.Version = e.Version; this.FirstName = e.FirstName; this.LastName = e.LastName; this.DeliveryAddress = new Address(e.Street, e.HouseNumber, e.PostalCode, e.City); }
public Task Apply(CustomerCreated @event) { var customer = new CustomerOverviewViewModel { CustomerId = @event.Id, Name = @event.Name }; return(InsertAsync(customer)); }
private void Handle(CustomerCreated evt) { var customer = new Customer() { Id = evt.Id, Name = evt.Name }; _indexer.Index(customer); _graphIndexer.AddCustomer(customer); }
public void WhenApplyingCustomerCreatedEvent_ThenShouldHaveIdSet() { var customer = new Customer { Id = Guid.NewGuid() }; var customerCreated = new CustomerCreated(customer); customer.Apply(customerCreated); Assert.Equal(customerCreated.EntityId, customer.Id); }
public void When(CustomerCreated e) { Func<CustomerIndexLookUp> create; create = ()=> { var index = new CustomerIndexLookUp(); index.Customers.Add(key: e.CustomerName, value: e.Id); return index; }; writer.AddOrUpdate(unit.it, create(), i => i.Customers.Add(key: e.CustomerName, value: e.Id)); }
public async Task <IActionResult> PublishCustomer([FromBody] CreateCustomerRequest request) { //_customerService.CreateCustomer(request); var customerCreated = new CustomerCreated { Id = request.Id, FullName = request.FullName, DateOfBirth = request.DateOfBirth }; await _messagePublisher.Publish(customerCreated); return(Ok()); }
public async Task <IActionResult> PublishCustomer([FromBody] CreateCustomerRequest request) { //_customerService.CreateCustomer(request); var customerCreated = new CustomerCreated { Id = request.Id, UserName = request.UserName, Email = request.Email, PhoneNumber = request.PhoneNumber }; await _messagePublisher.Publish(customerCreated); return(Ok()); }
public void Handle(CustomerCreated message) { if (Data.Customer != null) { return; } flowLog.LogFlow(message.CustomerId, "Created customer saga for {0}", message.Name); Data.Customer = new CustomerInformation { CustomerId = message.CustomerId, Name = message.Name, }; }
private void Handle(CustomerCreated evt) { var customer = new Customer() { Id = evt.Id, Name = evt.Name }; _indexer.Index(customer); _graphClient.Cypher .Create("(customer:Customer {newCustomer})") .WithParam("newCustomer", customer) .ExecuteWithoutResults(); }
public async Task HandleAsync(SignedUp @event, ICorrelationContext context) { Customer customer = new Customer(@event.UserId); customer.Create(@event.FirstName, @event.AccountType, @event.LastName); customer.SetEmail(@event.Email); customer.Use(); await _customerRepo.AddAsync(customer); //Publish event that new customer has signed up CustomerCreated customerCreated = new CustomerCreated(@event.UserId, @event.FirstName, @event.LastName, @event.Email, ""); await _busPublisher.PublishAsync(customerCreated, null); }
public Customer(DomainHandler domainHandler, string nome, string email, string senha) { _domainHandler = domainHandler; Id = Guid.NewGuid(); Nome = nome; Email = email; Senha = senha; CustomerCreated = new CustomerCreated(); _domainHandler.AddEvent(CustomerCreated); EventMapping.MapProducer(CustomerCreated); domainHandler.CommandHandler += DomainHandler_CommandHandler; }
public async Task <CustomerDto> Handle(CreateCustomerCommand cmd, CancellationToken cancellationToken) { // Raising Event ... var @event = new CustomerCreated(Guid.NewGuid(), cmd.FirstName, cmd.LastName, DateTime.UtcNow); //await _mediator.Publish(@event, cancellationToken); var res = new CustomerDto() { FirstName = cmd.FirstName, LastName = cmd.LastName, }; //await Task.CompletedTask; await _eventStoreDbContext.AppendToStreamAsync(@event); return(res); }
internal void RecordedEvent( RecordedEvent rec, long eventID, Guid streamID, DefaultEventMetadata metadata, CustomerCreated e, RecordedEvent act, BsonDocument doc ) { GIVEN["a recorded event"] = () => { rec = new RecordedEvent( streamID = Guid.NewGuid(), e = new CustomerCreated { Name = "Customer 1" }, metadata = new DefaultEventMetadata(DateTime.Today)); rec.ID = new EventID(eventID = 100_000_000_000); }; AND["an appropriate configuration"] = () => ConfigureSerialization(); WHEN["serializing the event"] = () => doc = Serialize(rec); THEN["the BSON is as expected"] = () => { var exp = new BsonDocument { { "_id", new BsonInt64(eventID) }, { "StreamID", new BsonBinaryData(streamID, GuidRepresentation.Standard) }, { "m", new BsonDocument { { "ts", new BsonDateTime(metadata.Timestamp) }, { "c", BsonNull.Value } } }, { "e", new BsonDocument { { "_t", "TEST:Test.CustomerCreated" }, { "Name", e.Name }, { "CreationDate", e.CreationDate } } } }; doc.Should().BeEqivalentTo(exp); }; AND["deserializing it"] = () => act = Deserialize <RecordedEvent>(doc); THEN["it has the same value"] = () => act.Should().BeEquivalentTo(rec); }
public async Task <CustomerDto> Handle(CreateCustomerCommand cmd, CancellationToken cancellationToken) { var @event = new CustomerCreated(Guid.NewGuid(), cmd.FirstName, cmd.LastName, DateTime.UtcNow); //do sth var res = new CustomerDto() { Id = @event.Id, FirstName = cmd.FirstName, LastName = cmd.LastName, CreatedOn = @event.CreatedOn }; await _eventStoreDbContext.AppendToStreamAsync(@event); return(res); }
public void Handle(CustomerCreated message) { // we're idempotent! if (Data.CustomerId != Guid.Empty) { return; } var customerId = message.CustomerId; flowLog.LogFlow(customerId, "Commencing legal check of {0}", message.Name); Data.CustomerId = customerId; bus.Defer(8.Seconds(), new SimulatedLegalCheckComplete { CustomerId = customerId }); }
public void AggregateRootApplyEventTest() { Given("a Customer AggregateRoot", context => { context.State.AggregatRoot = new Customer(); }) .When("a CustomerCreated event was applied", context => { var domainEvent = new CustomerCreated { Name = "Hans Wurst" }; context.State.Event = domainEvent; ((Customer)context.State.AggregatRoot).ApplyEvent(domainEvent); }) .Then("the Customer AggregateRoot should have the Name property set to the same of the event", context => (((Customer)context.State.AggregatRoot).Name == "Hans Wurst")) .And("the event could be found in applied events list", context => ((Customer)context.State.AggregatRoot).AppliedEvents.Contains(((CustomerCreated)context.State.Event))); }
/// <summary> /// Setup the Commands /// </summary> private void InitCommands() { Command <CreateCustomer>(cmd => { var evt = new CustomerCreated(cmd.Id, cmd.FirstName, cmd.LastName); Persist(evt, e => { _readStore.CreateCustomer(new Customer { CustomerId = evt.Id, CustomerName = $"{evt.FirstName} {evt.LastName}", }); Context.System.EventStream.Publish(e); }); }); Command <UpdateCustomer>(cmd => { var evt = new CustomerUpdated(cmd.Id, cmd.FirstName, cmd.LastName); Persist(evt, e => { _readStore.UpdateCustomer(new Customer { CustomerId = evt.Id, CustomerName = $"{evt.FirstName} {evt.LastName}", }); Context.System.EventStream.Publish(e); }); }); Command <DeleteCustomer>(cmd => { var evt = new CustomerDeleted(cmd.Id); Persist(evt, e => { _readStore.DeleteCustomerById(evt.Id); Context.System.EventStream.Publish(e); }); }); }
public async Task Raised_Event_Should_Be_In_Mongo() { var command = new CustomerCreated(Guid.NewGuid(), "Younes", "Baghaie Moghaddam", DateTime.Now); var jsonCustomer = JsonConvert.SerializeObject(command); // create a customer var customerData = new StringContent(jsonCustomer, UTF8Encoding.UTF8, "application/json"); var createCustomerResponse = await _commandApi.PostAsync("api/Customers/CreateCustomer", customerData); createCustomerResponse.EnsureSuccessStatusCode(); var createCustomerString = await createCustomerResponse.Content.ReadAsStringAsync(); var createdCustomer = JsonConvert.DeserializeObject <CustomerCreated>(createCustomerString); var getCustomerResponse = await _queryApi.TryGetAsync($@"api/Customers/GetCustomer?id={ createdCustomer.Id }"); var getCustomerString = await getCustomerResponse.Content.ReadAsStringAsync(); var retrievedCustomer = JsonConvert.DeserializeObject <CustomerCreated>(getCustomerString); createdCustomer.Id.Should().Be(retrievedCustomer.Id); }
public void Handle(CustomerCreated message) { // we're idempotent! if (Data.CustomerInfo != null) { return; } var customerId = message.CustomerId; flowLog.LogFlow(customerId, "Commencing credit check of {0}", message.Name); Data.CustomerInfo = new CustomerInfo { CustomerId = customerId, CustomerName = message.Name, }; bus.Defer(random.Next(5).Seconds() + 5.Seconds(), new SimulatedCreditCheckComplete { CustomerId = customerId }); }
public void Handle(CustomerCreated message) { var context = GlobalHost.ConnectionManager.GetHubContext <CustomerHub>(); context.Clients.All.customerCreated(message.Id, message.Name, message.EmailAddress); }
public void When(CustomerCreated e) { this.Id = e.Id; this.Name = e.CustomerName; this._created = true; }
public void On(CustomerCreated @event) { Id = Guid.Parse(@event.CustomerId); FirstName = @event.FirstName; LastName = @event.LastName; }
private void Apply(CustomerCreated @event) { this._id = @event.Id; this.name = @event.Name; }
public async Task CompensateAsync(CustomerCreated message, ISagaContext context) { Data.CustomerCreatedAt = DateTime.UtcNow; await Task.CompletedTask; }
private void Apply(CustomerCreated @event) { }
public void When(CustomerCreated e) { _store.Add(e.Id, new CustomerTransactions()); }
public void Apply(CustomerCreated e) { PrimaryAccountHolder = e.PrimaryAccountHolder; MailingAddress = e.MailingAddress; }
public async Task HandleAsync(CustomerCreated message, ISagaContext context) { await Task.CompletedTask; }
private void HandleEvent(CustomerCreated @event) { this.Name = @event.Name; this.UserId = @event.UserId; }
public void When(CustomerCreated evt) { Id = evt.Id; Name = evt.Name; Address = evt.Adress; }
private void Apply(CustomerCreated obj) { Id = obj.Id; }
private void Apply(CustomerCreated evt) { Id = evt.AggregateId; }