public async void HandleXX(CreateSchemaCommand command) { Guid gSchemaId = new Guid("42E5B6A3-0B76-4FE7-B780-71935086B8ED"); var storedSchemaX = await _repository.Load <Schema>(gSchemaId, Int32.MaxValue); if (storedSchemaX == null) { Console.WriteLine("Item is not found. Create a new one."); } var schema = new Schema(gSchemaId); // = _repository.LoadNew<Schema>(); schema.AddProperty("A"); schema.AddProperty("BC"); await _repository.Save(schema); // query event store for events var storedSchema = await _repository.Load <Schema>(gSchemaId, Int32.MaxValue); if (storedSchema == null) { Console.WriteLine("Item STILL not found."); } else { storedSchema.AddProperty("CD"); await _repository.Save(storedSchema); } }
public async Task <Either <Error, Nothing> > Handle(CancellationToken cancelationToken, NonEmptyGuid id, Action <TAggregate> whatToDo) { var aggregate = await _aggregateStore.Load <TAggregate>(id, cancelationToken); whatToDo(aggregate); await _aggregateStore.Save(aggregate, cancelationToken); return(Nothing.Instance); }
public Task <Unit> Handle(CutInnerConduitCommand request, CancellationToken cancellationToken) { // Id check if (request.InnerConduitId == null && request.MultiConduitId == null) { throw new ArgumentException("Either InnerConduitId or MultiConduitId + InnerConduitSequenceNumber must be provided."); } if (request.MultiConduitId == null || request.MultiConduitId == Guid.Empty) { var conduitRelations = conduitNetworkQueryService.GetConduitSegmentsRelatedToPointOfInterest(request.PointOfInterestId); if (!conduitRelations.Any(c => c.Segment.Line.Id == request.InnerConduitId)) { throw new ArgumentException("Cannot find inner conduit with id: " + request.InnerConduitId + " in point of interest: " + request.PointOfInterestId); } var innerConduitSegment = conduitRelations.Find(c => c.Segment.Line.Id == request.InnerConduitId); request.MultiConduitId = ((ConduitInfo)innerConduitSegment.Segment.Line).GetRootConduit().Id; request.InnerConduitSequenceNumber = innerConduitSegment.Segment.Line.SequenceNumber; } var multiConduit = repo.Load <MultiConduit>(request.MultiConduitId); multiConduit.CutInnerConduit(request.InnerConduitSequenceNumber, request.PointOfInterestId, routeNetworkQueryService, conduitNetworkQueryService); repo.Store(multiConduit); return(Unit.Task); }
public Task <Unit> Handle(CutSingleConduitCommand request, CancellationToken cancellationToken) { // Id check if (request.SingleConduitId == null || request.SingleConduitId == Guid.Empty) { throw new ArgumentException("MultiConduitId cannot be null or empty"); } var singleConduit = repo.Load <SingleConduit>(request.SingleConduitId); singleConduit.Cut(request.PointOfInterestId, routeNetworkQueryService, conduitNetworkQueryService); repo.Store(singleConduit); return(Unit.Task); }
public Task <Unit> Handle(RemoveConduitClosureCommand request, CancellationToken cancellationToken) { // Id check if (request.ConduitClosureId == null || request.ConduitClosureId == Guid.Empty) { throw new ArgumentException("ConduitClosureId cannot be null or empty"); } var conduitClosure = repo.Load <ConduitClosure>(request.ConduitClosureId); conduitClosure.Remove(); repo.Store(conduitClosure); return(Unit.Task); }
public void Handle(RemoveProductFromCart removeProductFromCart) { var cart = _repository.Load <ShoppingCart>(removeProductFromCart.CartId); cart.RemoveProduct(removeProductFromCart.ProductId); _repository.SaveChanges(cart); }
public void Handle(AddProductToCart message) { var cart = _repository.Load <ShoppingCart>(message.CartId); cart.AddProduct(message.ProductId); _repository.SaveChanges(cart); }
private static async Task CancelOrder(IAggregateRepository repository, ILogger log, OrderPlaced @event) { var order = await repository.Load <Order>(@event.OrderId); log.LogInformation("The customer cancelled"); if (order != null) { order.Cancel("Customer requested cancellation"); await repository.Save(order); } }
private static async Task ProvisionOrder(IAggregateRepository repository, ILogger log, OrderPlaced @event) { log.LogInformation("The cooldown expired"); var order = await repository.Load <Order>(@event.OrderId); // order is ready to go, cooling period expired if (order != null) { order.Provision(); await repository.Save(order); } }
/// <summary> /// Executes an action to an existing AR. Use this method only if you are 100% sure that the AR must exist. /// If the AR does not exists the method throws an exception. /// </summary> /// <param name="id"></param> /// <param name="update"></param> public virtual void Update(IAggregateRootId id, Action <AR> update) { ReadResult <AR> result = repository.Load <AR>(id); if (result.IsSuccess) { update(result.Data); repository.Save(result.Data); } else { throw new Exception($"Failed to load an aggregate. {result}"); } }
public async Task <TAggregateRoot> Load(TId aggregateId, bool throwIfNotFound = true) { return(await repository.Load(aggregateId, throwIfNotFound)); }
public ReadResult <AR> Load <AR>(IAggregateRootId id) where AR : IAggregateRoot { return(aggregateRepository.Load <AR>(id)); }
public AR Load <AR>(IAggregateRootId id) where AR : IAggregateRoot { return(aggregateRepository.Load <AR>(id)); }