public void MoneyValueOf_WhenCurrencyIsProvided_IsSuccessful() { var value = MoneyValue.Of(120, "EUR"); Assert.That(value.Value, Is.EqualTo(120)); Assert.That(value.Currency, Is.EqualTo("EUR")); }
public void PlaceOrder_WhenAtLeastOneProductIsAdded_IsSuccessful() { // Arrange Customer customer = CustomerFactory.Create(); List <OrderProductData> orderProductsData = new List <OrderProductData>(); orderProductsData.Add(new OrderProductData(SampleProducts.Product1Id, 2)); List <ProductPriceData> allProductPrices = new List <ProductPriceData> { SampleProductPrices.Product1EUR, SampleProductPrices.Product1USD }; const string currency = "EUR"; List <ConversionRate> conversionRates = GetConversionRates(); // Act customer.PlaceOrder( orderProductsData, allProductPrices, currency, conversionRates); // Assert OrderPlacedEvent orderPlaced = AssertPublishedDomainEvent <OrderPlacedEvent>(customer); Assert.That(orderPlaced.Value, Is.EqualTo(MoneyValue.Of(200, "EUR"))); }
public void MoneyValueOf_WhenCurrencyIsNotProvided_ThrowsMoneyValueMustHaveCurrencyRuleBroken() { AssertBrokenRule <MoneyValueMustHaveCurrencyRule>(() => { MoneyValue.Of(120, ""); }); }
private void When(PriceListItemAttributesChangedDomainEvent @event) { this._countryCode = @event.CountryCode; this._subscriptionPeriod = SubscriptionPeriod.Of(@event.SubscriptionPeriodCode); this._category = PriceListItemCategory.Of(@event.CategoryCode); this._price = MoneyValue.Of(@event.Price, @event.Currency); }
public async Task <Guid> Handle(BuySubscriptionRenewalCommand command, CancellationToken cancellationToken) { var priceList = await PriceListProvider.GetPriceList(_sqlConnectionFactory.GetOpenConnection()); var subscriptionId = new SubscriptionId(command.SubscriptionId); var subscription = await _aggregateStore.Load(new SubscriptionId(command.SubscriptionId)); if (subscription == null) { throw new InvalidCommandException(new List <string> { "Subscription for renewal must exist." }); } var subscriptionRenewalPayment = SubscriptionRenewalPayment.Buy( _payerContext.PayerId, subscriptionId, SubscriptionPeriod.Of(command.SubscriptionTypeCode), command.CountryCode, MoneyValue.Of(command.Value, command.Currency), priceList); _aggregateStore.AppendChanges(subscriptionRenewalPayment); return(subscriptionRenewalPayment.Id); }
private void When(MeetingFeeCreatedDomainEvent meetingFeeCreated) { this.Id = meetingFeeCreated.MeetingFeeId; _payerId = new PayerId(meetingFeeCreated.PayerId); _meetingId = new MeetingId(meetingFeeCreated.MeetingId); _fee = MoneyValue.Of(meetingFeeCreated.FeeValue, meetingFeeCreated.FeeCurrency); _status = MeetingFeeStatus.Of(meetingFeeCreated.Status); }
private void When(PriceListItemCreatedDomainEvent @event) { this.Id = @event.PriceListItemId; _countryCode = @event.CountryCode; _subscriptionPeriod = SubscriptionPeriod.Of(@event.SubscriptionPeriodCode); _category = PriceListItemCategory.Of(@event.CategoryCode); _price = MoneyValue.Of(@event.Price, @event.Currency); _isActive = true; }
private void When(SubscriptionPaymentCreatedDomainEvent @event) { this.Id = @event.SubscriptionPaymentId; _payerId = new PayerId(@event.PayerId); _subscriptionPeriod = SubscriptionPeriod.Of(@event.SubscriptionPeriodCode); _countryCode = @event.CountryCode; _subscriptionPaymentStatus = SubscriptionPaymentStatus.Of(@event.Status); _value = MoneyValue.Of(@event.Value, @event.Currency); }
public void GivenTwoMoneyValuesWithDifferentCurrencies_WhenAddThem_ThrowsMoneyValueOperationMustBePerformedOnTheSameCurrencyRule() { var valueInEuros = MoneyValue.Of(100, "EUR"); var valueInDollars = MoneyValue.Of(50, "USD"); AssertBrokenRule <MoneyValueOperationMustBePerformedOnTheSameCurrencyRule>(() => { var add = valueInEuros + valueInDollars; }); }
public void GivenTwoMoneyValuesWithTheSameCurrencies_WhenAddThem_IsSuccessful() { var valueInEuros = MoneyValue.Of(100, "EUR"); var valueInEuros2 = MoneyValue.Of(50, "EUR"); MoneyValue add = valueInEuros + valueInEuros2; Assert.That(add.Value, Is.EqualTo(150)); Assert.That(add.Currency, Is.EqualTo("EUR")); }
public CreateAddOnCommand(long restaurantId, long foodId, string name, string nameEng, string description, string descriptionEng, decimal price) { RestaurantId = restaurantId; FoodId = foodId; Name = name; NameEng = nameEng; Description = description; DescriptionEng = descriptionEng; Price = MoneyValue.Of(price); }
public Task <Guid> Handle(CreateMeetingFeeCommand command, CancellationToken cancellationToken) { var meetingFee = MeetingFee.Create( new PayerId(command.PayerId), new MeetingId(command.MeetingId), MoneyValue.Of(command.Value, command.Currency)); _aggregateStore.AppendChanges(meetingFee); return(Task.FromResult(meetingFee.Id)); }
public async Task <Unit> Handle(CreateMeetingPaymentCommand request, CancellationToken cancellationToken) { var meetingPayment = MeetingPayment.CreatePaymentForMeeting( request.PayerId, request.MeetingId, MoneyValue.Of(request.Value, request.Currency)); await _meetingPaymentRepository.AddAsync(meetingPayment); return(Unit.Value); }
public void MeetingPayment_WhenFeeIsNotGreaterThanZero_CannotBeCreated() { var payerId = new PayerId(Guid.NewGuid()); var meetingId = new MeetingId(Guid.NewGuid()); var fee = MoneyValue.Of(0, "EUR"); AssertBrokenRule <MeetingPaymentFeeMustBeGreaterThanZeroRule>(() => { MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee); }); }
public Task <Guid> Handle(CreatePriceListItemCommand command, CancellationToken cancellationToken) { var priceListItem = PriceListItem.Create( command.CountryCode, SubscriptionPeriod.Of(command.SubscriptionPeriodCode), PriceListItemCategory.Of(command.CategoryCode), MoneyValue.Of(command.PriceValue, command.PriceCurrency)); _aggregateStore.AppendChanges(priceListItem); return(Task.FromResult(priceListItem.Id)); }
public async Task <Unit> Handle(ChangePriceListItemAttributesCommand command, CancellationToken cancellationToken) { var priceListItem = await _aggregateStore.Load(new PriceListItemId(command.PriceListItemId)); priceListItem.ChangeAttributes( command.CountryCode, SubscriptionPeriod.Of(command.SubscriptionPeriodCode), PriceListItemCategory.Of(command.CategoryCode), MoneyValue.Of(command.PriceValue, command.PriceCurrency)); _aggregateStore.AppendChanges(priceListItem); return(Unit.Value); }
public void GivenTwoMoneyValuesWithTheSameCurrencies_SumThem_IsSuccessful() { MoneyValue valueInEuros = MoneyValue.Of(100, "EUR"); MoneyValue valueInEuros2 = MoneyValue.Of(50, "EUR"); IList <MoneyValue> values = new List <MoneyValue> { valueInEuros, valueInEuros2 }; MoneyValue add = values.Sum(); Assert.That(add.Value, Is.EqualTo(150)); Assert.That(add.Currency, Is.EqualTo("EUR")); }
private PriceList CreatePriceList() { var priceListItem = new PriceListItemData( "PL", SubscriptionPeriod.Month, MoneyValue.Of(60, "PLN"), PriceListItemCategory.New); var priceList = PriceList.CreateFromItems(new List <PriceListItemData> { priceListItem }); return(priceList); }
public void MeetingPayment_WhenFeeIsGreaterThanZero_IsCreated() { var payerId = new PayerId(Guid.NewGuid()); var meetingId = new MeetingId(Guid.NewGuid()); var fee = MoneyValue.Of(100, "EUR"); var meetingPayment = MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee); var meetingCreated = AssertPublishedDomainEvent <MeetingPaymentCreatedDomainEvent>(meetingPayment); Assert.That(meetingCreated.PayerId, Is.EqualTo(payerId)); Assert.That(meetingCreated.MeetingId, Is.EqualTo(meetingId)); Assert.That(meetingCreated.Fee, Is.EqualTo(fee)); }
public void CreatePriceListItem_IsSuccessful() { // Act var priceListItem = PriceListItem.Create( "BRA", SubscriptionPeriod.Month, PriceListItemCategory.New, MoneyValue.Of(50, "BRL")); // Assert var priceListItemCreated = AssertPublishedDomainEvent <PriceListItemCreatedDomainEvent>(priceListItem); Assert.That(priceListItemCreated.PriceListItemId, Is.EqualTo(priceListItem.Id)); }
public static async Task <List <ProductPriceData> > GetAllProductPrices(IDbConnection connection) { var productPrices = await connection.QueryAsync <ProductPriceResponse>("SELECT " + $"[ProductPrice].ProductId AS [{nameof(ProductPriceResponse.ProductId)}], " + $"[ProductPrice].Value AS [{nameof(ProductPriceResponse.Value)}], " + $"[ProductPrice].Currency AS [{nameof(ProductPriceResponse.Currency)}] " + "FROM orders.v_ProductPrices AS [ProductPrice]"); return(productPrices.AsList() .Select(x => new ProductPriceData( new ProductId(x.ProductId), MoneyValue.Of(x.Value, x.Currency))) .ToList()); }
public static async Task <PriceList> GetPriceList(IDbConnection connection) { var priceListItemList = await GetPriceListItems(connection); return(PriceList.CreateFromItems( priceListItemList .Select(x => new PriceListItemData( x.CountryCode, SubscriptionPeriod.Of(x.SubscriptionPeriodCode), MoneyValue.Of(x.MoneyValue, x.MoneyCurrency), PriceListItemCategory.Of(x.CategoryCode))) .ToList())); }
private PriceList CreatePriceList() { var priceListItem = new PriceListItemData( "PL", SubscriptionPeriod.Month, MoneyValue.Of(60, "PLN"), PriceListItemCategory.New); var priceListItems = new List <PriceListItemData> { priceListItem }; var priceList = PriceList.Create(priceListItems, new DirectValueFromPriceListPricingStrategy(priceListItems)); return(priceList); }
public void ActivatePriceListItem_WhenItemIsActive_ThenActivationIgnored() { // Arrange var priceListItem = PriceListItem.Create( "BRA", SubscriptionPeriod.Month, PriceListItemCategory.New, MoneyValue.Of(50, "BRL")); // Act priceListItem.Activate(); // Assert AssertDomainEventNotPublished <PriceListItemActivatedDomainEvent>(priceListItem); }
public void MarkPaymentAsPayed_WhenIsPayedAlready_CannotBePayedTwice() { var payerId = new PayerId(Guid.NewGuid()); var meetingId = new MeetingId(Guid.NewGuid()); var fee = MoneyValue.Of(100, "EUR"); var meetingPayment = MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee); meetingPayment.MarkIsPayed(); AssertBrokenRule <MeetingPaymentCannotBePayedTwiceRule>(() => { meetingPayment.MarkIsPayed(); }); }
public async Task <Guid> Handle(BuySubscriptionCommand command, CancellationToken cancellationToken) { var priceList = await PriceListProvider.GetPriceList(_sqlConnectionFactory.GetOpenConnection()); var subscription = SubscriptionPayment.Buy( _payerContext.PayerId, SubscriptionPeriod.Of(command.SubscriptionTypeCode), command.CountryCode, MoneyValue.Of(command.Value, command.Currency), priceList); _aggregateStore.AppendChanges(subscription); return(subscription.Id); }
public async Task <Unit> Handle(ChangeMeetingMainAttributesCommand request, CancellationToken cancellationToken) { var meeting = await _meetingRepository.GetByIdAsync(new MeetingId(request.MeetingId)); meeting.ChangeMainAttributes(request.Title, MeetingTerm.CreateNewBetweenDates(request.TermStartDate, request.TermStartDate), request.Description, MeetingLocation.CreateNew(request.MeetingLocationName, request.MeetingLocationAddress, request.MeetingLocationPostalCode, request.MeetingLocationCity), MeetingLimits.Create(request.AttendeesLimit, request.GuestsLimit), Term.CreateNewBetweenDates(request.RSVPTermStartDate, request.RSVPTermEndDate), request.EventFeeValue.HasValue ? MoneyValue.Of(request.EventFeeValue.Value, request.EventFeeCurrency) : MoneyValue.Undefined, _memberContext.MemberId); return(Unit.Value); }
public void BuySubscription_IsSuccessful() { // Arrange var subscriptionPaymentTestData = CreateSubscriptionPaymentTestData(); // Act var subscriptionPayment = SubscriptionPayment.Buy( subscriptionPaymentTestData.PayerId, SubscriptionPeriod.Month, "PL", MoneyValue.Of(60, "PLN"), subscriptionPaymentTestData.PriceList); // Assert AssertPublishedDomainEvent <SubscriptionPaymentCreatedDomainEvent>(subscriptionPayment); }
public void BuySubscriptionRenewal_WhenPriceDoesNotExist_IsNotPossible() { // Arrange var subscriptionPaymentTestData = CreateSubscriptionPaymentTestData(); // Act & Assert AssertBrokenRule <PriceOfferMustMatchPriceInPriceListRule>(() => { SubscriptionPayment.Buy( subscriptionPaymentTestData.PayerId, SubscriptionPeriod.Month, "PL", MoneyValue.Of(50, "PLN"), subscriptionPaymentTestData.PriceList); }); }
public Result <bool> UpdateVariantPrice(VariantPriceUpdateModel model) { var variant = _variants.FirstOrDefault(x => x.Name.ToLowerInvariant() == model.VariantName.ToLowerInvariant()); if (variant.HasValue()) { if (model.VariantName.Equals(DefaultVariant)) { UpdateBasePrice(model.NewPrice); } variant.UpdatePrice(MoneyValue.Of(model.NewPrice)); return(Result.Ok(variant.IsPriceReduced())); } return(Result.Failure <bool>("failed to update")); }