public HttpResponseMessage Create([FromBody] RegistreerDeelnemerCommand command) { var deelnemer = new PensioenSysteem.Domain.Deelnemer.Deelnemer(); deelnemer.Registreer(command); _repo.Save(deelnemer, -1); return(new HttpResponseMessage(HttpStatusCode.Created)); }
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 async Task Handle(AddShip command) { var aggregateGame = await _store.GetById <Game>(command.GameId); if (aggregateGame.AddShip(command.ShipDetails, command.PlayerIndex)) { // ship was added, persist aggregate await _store.Save(aggregateGame, aggregateGame.Version); } }
public async Task <PaymentId> CreatePayment(string cardNumber, int ccv, int expiryMonthDate, int expiryYearDate, double amount, Currency currency) { var card = CreditCard.Create(CardNumber.Create(cardNumber), ExpiryDate.Create(expiryMonthDate, expiryYearDate, _dateProvider), Ccv.Create(ccv)); var money = Money.Create(amount, currency); var payment = new Payment(PaymentId.Create(), card, money); await _paymentRepository.Save(payment); return(payment.Id); }
public async Task Save(IAggregate aggregate) { if (_aggregateTracking != null) { _aggregateTracking.TrackEvents(aggregate); } var orderedEvents = _aggregateRepository.Save(aggregate); foreach (var @event in orderedEvents) { await _eventListener.Handle(@event); } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, [Inject] IAggregateRepository repository, [Inject] IOrderHistory orderHistory, [Inject] ICustomerHistory customerHistory) { var dict = req.GetQueryParameterDictionary(); var validator = new PlaceOrderValidator(); var result = await validator.Validate( GetValueOrDefault("OrderNumber", dict), GetValueOrDefault("CustomerId", dict), orderHistory, customerHistory); if (!result.HasPassed) { return(new BadRequestObjectResult(result.Errors)); } var order = new Order(); order.Place(validator.CustomerId, validator.OrderNumber); await repository.Save(order); return(new OkObjectResult("Thanks for placing an order")); }
protected override async Task HandleCore(UpdateTicketStatusCommand message) { var ticket = await _repository.Get <Ticket>(message.TicketId); ticket.UpdateStatus(message.StatusId, message.UserId); await _repository.Save(ticket); }
public async Task Handle(AddTicketCommentCommand message) { var ticket = await _repository.Get <Ticket>(message.TicketId); ticket.AddComment(message.Comment, message.UserId); await _repository.Save(ticket); }
protected override async Task HandleCore(AddTicketCommentCommand message) { var ticket = await _repository.Get <Ticket>(message.TicketId); ticket.AddComment(message.Comment, message.UserId); await _repository.Save(ticket); }
protected override async Task HandleCore(UpdateTicketPriorityCommand message) { var ticket = await _repository.Get <Ticket>(message.TicketId); ticket.UpdatePriority(message.PriorityId, message.UserId); await _repository.Save(ticket); }
public void Handle(RenameInventoryItem command) { var inventoryItem = _repository.GetById(command.InventoryItemId); inventoryItem.ChangeName(command.NewName); _repository.Save(inventoryItem); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> public void Execute(TransactionSplitCommand command) { if (command.Shares == 0) { throw new DomainValidationException("Shares", "Cannot sell zero units"); } //TODO: Further Validation if (_book.GetOrAddOpenPosition(command.StockId).Shares == 0) { throw new DomainValidationException("Shares", "The amount of available shares cannot be zero for a split/reverse split."); } //Create new transaction var transaction = new TransactionAggregate(); transaction.CreateSplitTransaction( command.AggregateId, command.OrderDate, command.Shares, command.PricePerShare, command.StockId); //Save transaction _repository.Save(transaction, -1); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> public void Execute(TransactionDividendCommand command) { if (command.Shares == 0) { throw new DomainValidationException("Shares", "Cannot sell zero units"); } //TODO: Further Validation if (_book.GetOrAddOpenPosition(command.StockId).Shares < command.Shares) { throw new DomainValidationException("Shares", "The amount of available units for the stock is smaller than those used in the dividend."); } //Create new transaction var transaction = new TransactionAggregate(); transaction.CreateDividendTransaction( command.AggregateId, command.OrderDate, command.Shares, command.PricePerShare, command.OrderCosts, command.Description, command.Tag, command.Image, command.StockId, command.Taxes); //Save transaction _repository.Save(transaction, -1); }
public async Task Consume(ConsumeContext <CreateArticle> context) { var article = _aggregateRepository.Get <Domain.Article>(context.Message.Id); article.Create(context.Message); _aggregateRepository.Save(article); await Console.Out.WriteLineAsync($"Article Created : {context.Message.ToJson()}"); }
public HttpResponseMessage Create([FromBody] RegistreerWerkgeverCommand command) { var werkgever = new PensioenSysteem.Domain.Werkgever.Werkgever(); werkgever.Registreer(command); _repo.Save(werkgever, -1); return(new HttpResponseMessage(HttpStatusCode.Created)); }
public HttpResponseMessage Create([FromBody] RegistreerArbeidsverhoudingCommand command) { var arbeidsverhouding = new PensioenSysteem.Domain.Arbeidsverhouding.Arbeidsverhouding(); arbeidsverhouding.Registreer(command); _repo.Save(arbeidsverhouding, -1); return(new HttpResponseMessage(HttpStatusCode.Created)); }
public virtual async Task Handle(TCommand command, CancellationToken cancellationToken) { var aggregateId = command.GetAggregateId(); var aggregate = await _aggregateRepository.GetById <TAggregate>(aggregateId, cancellationToken); HandleCommand(aggregate, command); await _aggregateRepository.Save(aggregate, cancellationToken); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> /// <exception cref="DomainValidationException">Thrown if validation fails</exception> public void Execute(StrategyRemoveCommand command) { var aggregate = _repository.GetById(command.AggregateId); aggregate.Remove(); _repository.Save(aggregate, command.OriginalVersion); }
public static Task Save( [NotNull] this IAggregateRepository repository, IAggregate aggregate, Guid commitId) { Ensure.That(repository, "repository").IsNotNull(); return(repository.Save(aggregate, commitId, a => { }, CancellationToken.None)); }
public async Task Should_persist_an_aggregate_with_100_events() { // Arrange var car = new Car(_carId); for (var i = 1; i <= 100; i++) { car.Travel(i); } // Act await _repository.Save(car); var savedModel = await _repository.Get(_carId); // Assert savedModel.Should().BeEquivalentTo(car); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> /// <exception cref="DomainValidationException">Thrown if validation fails</exception> public void Execute(FeedbackChangeCommand command) { var aggregate = _repository.GetById(command.AggregateId); aggregate.ChangeName(command.Name); aggregate.ChangeDescription(command.Description); _repository.Save(aggregate, command.OriginalVersion); }
public void Execute(TCommand command) { var agg = _aggRepository.Get(command.Id); (agg as IAggHandleCommand <TCommand>).Execute(command); var events = agg.GetUncommittedChanges(); _aggRepository.Save(agg.Id, events, command.AggregateVersion); _eventPublisher.PublishEvents(events); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> public void Execute(TransactionRemoveCommand command) { //TODO: Validation var aggregate = _repository.GetById(command.AggregateId); aggregate.Undo(); _repository.Save(aggregate, command.OriginalVersion); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> /// <exception cref="DomainValidationException">Thrown if validation fails</exception> public void Execute(CalculationCopyCommand command) { var aggregate = _repository.GetById(command.OriginalId); var copy = new CalculationAggregate(); copy.Copy(aggregate, command.AggregateId); _repository.Save(copy, -1); }
public async Task Handle(CreateSchemaCommand command) { // Define id for the new schema (assume the id doesn't exist yet) Guid gSchemaId = Guid.NewGuid(); // create schema var schema = new Schema(gSchemaId); // set name schema.Rename(command.Name); // add properties foreach (var property in command.Properties) { schema.AddProperty(property); } // save await _repository.Save(schema); }
public static Task Save( [NotNull] this IAggregateRepository repository, string bucketId, IAggregate aggregate, Guid commitId, CancellationToken cancellationToken) { Ensure.That(repository, "repository").IsNotNull(); return(repository.Save(aggregate, bucketId, commitId, a => { }, cancellationToken)); }
public static Task Save( [NotNull] this IAggregateRepository repository, IAggregate aggregate, Guid commitId, Action <IDictionary <string, object> > updateHeaders, CancellationToken cancellationToken) { Ensure.That(repository, "repository").IsNotNull(); return(repository.Save(aggregate, DefaultBucket, commitId, updateHeaders, cancellationToken)); }
/// <summary> /// Executes the specified command. /// </summary> /// <param name="command">The command.</param> /// <returns></returns> /// <exception cref="DomainValidationException">Thrown if validation fails</exception> public void Execute(StockChangeCommand command) { var aggregate = _repository.GetById(command.AggregateId); aggregate.ChangeName(command.Name); aggregate.ChangeLongShort(command.LongShort); aggregate.ChangeType(command.Type); aggregate.ChangeWkn(command.Wkn); _repository.Save(aggregate, command.OriginalVersion); }
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); } }
/// <summary> /// Finds or creates a new aggregate if it doesn't exist, runs the update handler and saves it. /// </summary> /// <typeparam name="T">Type of the aggregate</typeparam> /// <param name="repository">repository instance</param> /// <param name="id">the aggregate id</param> /// <param name="handler">the create/update handler</param> /// <returns>A Task containing the created or updated aggregate</returns> public static async Task <T> CreateOrUpdate <T>(this IAggregateRepository <T> repository, string id, Action <T> handler) where T : IAggregate { var aggregate = await repository.FindOrDefault(id); handler(aggregate); await repository.Save(aggregate); return(aggregate); }
private async Task SaveAndTest(IAggregateRepository<IHomogeneousRole<RoleIdentifier>, RoleIdentifier> repo, params IHomogeneousRole<RoleIdentifier>[] roles) { foreach (var role in roles) await repo.Save(role); foreach (var role in roles) { var reconstituted = await repo.Get(role.Id); reconstituted.Should().NotBeNull(); reconstituted.Should().NotBeSameAs(role); reconstituted.Id.Should().Be(role.Id); reconstituted.Version.Should().Be(role.Version); reconstituted.Name.Should().Be(role.Name); reconstituted.Status.Should().Be(role.Status); } }