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 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();
}
private void Apply(CustomerCreated obj)
{
Id = obj.Id;
}
private void Apply(CustomerCreated evt)
{
Id = evt.AggregateId;
}
