protected async Task <CustomerAggregate> Prepare( IEventStore store, IAggregateRootServices services, ICollection <Action <CustomerAggregate> > useCaseActions) { Expect.NotNull(store, nameof(store)); Expect.NotNull(services, nameof(services)); Expect.NotEmpty(useCaseActions, nameof(useCaseActions)); var streamId = Guid.NewGuid().ToString("N"); var r = new CustomerAggregate(streamId, services); using (var sess = store.OpenSession(suppressAmbientTransaction: true)) { foreach (var action in useCaseActions) { action(r); var ok = await sess.SaveUncommitedEventsAsync <CustomerAggregate, Customer>(r).ConfigureAwait(false); if (!ok) { throw new Exception("failed to prepare root aggregate"); } } } return(r); }
/// <summary> /// This method flattens the customer data based on the Aggregate from MongoDB. /// </summary> /// <param name="aggregate"></param> /// <returns></returns> public static List <Customer> ToCustomerHierarchy(this CustomerAggregate aggregate) { List <Customer> customers = new List <Customer>(); var parentCustomer = string.Empty; var parentCount = 0; while (aggregate.Parents.Count > parentCount) { Customer customer = aggregate.Parents.Where(x => (x.Parent ?? string.Empty).Equals(parentCustomer)).FirstOrDefault(); customers.Add(customer); parentCustomer = customer.Name; parentCount++; } customers.Add(new Customer() { Name = aggregate.Name, CustomerId = aggregate.CustomerId, Address = aggregate.Address, Country = aggregate.Country, Id = aggregate.Id, Parent = aggregate.Parent, RMAddress = aggregate.RMAddress, RMName = aggregate.RMName }); return(customers); }
public void SetCustomer(CustomerAggregate customerAggregate) { customer = customerAggregate; var address = addressService.FindOne(customer.AddressId); SetFields(); }
static void Main(string[] args) { var customer = new CustomerAggregate(Enumerable.Empty <dynamic>()); customer.Deposit(new Money(20)); Console.WriteLine("Customer account balance is {0}", customer.AccountBalance); }
public void When_Making_A_Withdrawal() { var customer = new CustomerAggregate(Enumerable.Empty <dynamic>()); customer.Withdraw(new Money(10)); Assert.That(customer.Events.Any(x => x is CustomerWithdrawnMoney), Is.True); Assert.That(customer.AccountBalance, Is.EqualTo(-10)); }
public void When_Making_A_Deposit() { var customer = new CustomerAggregate(Enumerable.Empty <dynamic>()); customer.Deposit(new Money(10)); Assert.That(customer.Events.Any(x => x is CustomerDepositedMoney), Is.True); Assert.That(customer.AccountBalance, Is.EqualTo(10)); }
// [Authorize(Operations.RegisterCustomer)] => move to Facad service public void Handle(RegisterCustomerCommand command) { var homeAddress = new Address(command.HomeAddress_PostalCode, command.HomeAddress_City, command.HomeAddress_Province); var workAddress = new Address(command.WorkAddress_PostalCode, command.WorkAddress_City, command.WorkAddress_Province); var aggregate = new CustomerAggregate(command.FirstName, command.LastName, command.NationalCode, homeAddress, workAddress, bus); customerRepository.Create(aggregate); // aggregate.EventBus.Publish(new CustomerCreatedEvent(aggregate.Id)); }
public void When_Changing_Customers_Name() { var customer = new CustomerAggregate(Enumerable.Empty <dynamic>()); customer.ChangeName("Onam", "Chilwan"); Assert.That(customer.Events.Any(x => x is CustomerNameChanged), Is.True); Assert.That(customer.Forename, Is.EqualTo("Onam")); Assert.That(customer.Surname, Is.EqualTo("Chilwan")); }
public void Update(CustomerAggregate aggregate, int customerId) { var existingCustomer = FindOne(customerId); existingCustomer.lastUpdate = DateTime.Now.ToUniversalTime(); existingCustomer.lastUpdateBy = _authRepository.Username; existingCustomer.customerName = aggregate.CustomerName; existingCustomer.addressId = aggregate.AddressId; _repository.Update(existingCustomer, customerId); }
private void AddCustomer() { customer = new CustomerAggregate(); UpdateFields(); validateFields(); var addressId = UpdateAddress(); customer.AddressId = addressId; customerService.Add(customer); }
public async Task SaveUncommitedEventsSucceedsOnNoEvents() { var r = new CustomerAggregate(Guid.NewGuid().ToString("N"), Fixture.AggregateRootServices); using (var sess = Fixture.Store.OpenSession()) { var ok = await sess.SaveUncommitedEventsAsync <CustomerAggregate, Customer>(r).ConfigureAwait(false); Assert.True(ok, CreateMessage("saving while no uncommited events exist")); Assert.Equal(0, r.CurrentVersion); } }
public static CustomerAggregate AsDirtyCustomerAggregate( this ICollection <Action <CustomerAggregate> > useCase, IAggregateRootServices services, string streamId = null) { var id = streamId ?? Guid.NewGuid().ToString("N"); var r = new CustomerAggregate(id, services); foreach (var action in useCase) { action(r); } return(r); }
public void When_Loading_The_Customer() { var events = new List <dynamic>() { new CustomerNameChanged("Onam", "Chilwan"), new CustomerDepositedMoney(5.50M), new CustomerDepositedMoney(5M), new CustomerWithdrawnMoney(1.50M) }; var customer = new CustomerAggregate(events); Assert.That(customer.Events.ToList(), Is.Empty); Assert.That(customer.Forename, Is.EqualTo("Onam")); Assert.That(customer.Surname, Is.EqualTo("Chilwan")); Assert.That(customer.AccountBalance, Is.EqualTo(9M)); }
public async Task SaveAndHydrateWithinOneSession() { var r1 = UseCases.Simple().AsDirtyCustomerAggregate(Fixture.AggregateRootServices); using (var sess = Fixture.Store.OpenSession()) { var ok = await sess.SaveUncommitedEventsAsync <CustomerAggregate, Customer>(r1).ConfigureAwait(false); Assert.True(ok, CreateMessage("saving uncommited events")); var r2 = new CustomerAggregate(r1.StreamId, Fixture.AggregateRootServices); ok = await sess.HydrateAsync <CustomerAggregate, Customer>(r2).ConfigureAwait(false); Assert.True(ok, "hydrating previously saved user"); var result = Comparer.Compare(r1, r2); Assert.True(result.AreEqual, CreateMessage(result.DifferencesString)); } }
protected async Task <(bool ok, string error)> Verify(string streamId, CustomerAggregate expected) { var r = new CustomerAggregate(streamId, Fixture.AggregateRootServices); using (var sess = Fixture.Store.OpenSession(suppressAmbientTransaction: true)) { var ok = await sess.HydrateAsync <CustomerAggregate, Customer>(r).ConfigureAwait(false); if (!ok) { return(false, "failed to load & hydrate from the store"); } } var result = Comparer.Compare(r, expected); return(result.AreEqual ? (true, string.Empty) : (false, result.DifferencesString)); }
private async Task <CustomerAggregate> CreateExistingCustomerAggregate() { var createUnitOfWork = new CustomerUnitOfWork(Database, CollectionName); var createdCustomer = new CustomerAggregate { Name = "John Smith", DefaultAddresses = new CustomerDefaultAddresses { InvoiceAddress = new AddressAggregate { HouseName = "Invoice Address" } } }; createUnitOfWork.Customers.Add(createdCustomer); await createUnitOfWork.CommitAsync(); return(createdCustomer); }
public void Add(CustomerAggregate aggregate) { if (String.IsNullOrWhiteSpace(aggregate.CustomerName)) { throw new InvalidInputException("Must include name"); } var date = DateTime.Now.ToUniversalTime(); _repository.Add(new customer() { active = true, addressId = aggregate.AddressId, createDate = date, lastUpdate = date, createdBy = _authRepository.Username, lastUpdateBy = _authRepository.Username, customerName = aggregate.CustomerName, }); }
public void Update(CustomerAggregate customerAggregate) { throw new NotImplementedException(); }
public async Task Handle(RegisterCustomerCommand command) { var customer = new CustomerAggregate(command.FirstName, command.LastName, command.NationalCode); await _customerRepository.Save(customer); }
public void Create(CustomerAggregate customerAggregate) { session.Save(customerAggregate); }
public void Handle(AddSubscription c, CustomerAggregate customer) { customer.ChangeSubscription(c.LevelCode, c.StartDate); }
public void Handle(RemoveSubscription c, CustomerAggregate customer) { customer.RemoveSubscription(c.EndDate); }
public void Handle(Create c, CustomerAggregate customer) { customer.Create(c.CustomerName, c.LevelCode, c.StartDate); }
public void Add(Guid id, string name) { var customer = CustomerAggregate.Add(id, name); _repository.Save(customer, Guid.NewGuid(), null); }
public async Task Save(CustomerAggregate customerAggregate) { await _unitOfWork.Set <CustomerAggregate>().AddAsync(customerAggregate); }