Merge branch 'dev' into ExtensibleDtos

common.props

@@ -1,7 +1,7 @@
 <Project>
   <PropertyGroup>
     <LangVersion>latest</LangVersion>
-    <Version>0.14.0</Version>
+    <Version>0.14.1</Version>
     <NoWarn>$(NoWarn);CS1591</NoWarn>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Authors>EasyAbp Team</Authors>

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/EShopOrdersApplicationModule.cs

@@ -1,5 +1,7 @@
-using EasyAbp.EShop.Products;
+using EasyAbp.EShop.Orders.Orders;
+using EasyAbp.EShop.Products;
 using EasyAbp.EShop.Stores;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.AutoMapper;
 using Volo.Abp.Modularity;
@@ -18,6 +20,11 @@ namespace EasyAbp.EShop.Orders
         )]
     public class EShopOrdersApplicationModule : AbpModule
     {
+        public override void PreConfigureServices(ServiceConfigurationContext context)
+        {
+            context.Services.AddSingleton<IAuthorizationHandler, BasicOrderCreationAuthorizationHandler>();
+        }
+
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
             context.Services.AddAutoMapperObjectMapper<EShopOrdersApplicationModule>();

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/BasicOrderCreationAuthorizationHandler.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using EasyAbp.EShop.Orders.Orders.Dtos;
+using EasyAbp.EShop.Products.Products;
+using EasyAbp.EShop.Products.Products.Dtos;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    public class BasicOrderCreationAuthorizationHandler : OrderCreationAuthorizationHandler
+    {
+        protected override async Task HandleOrderCreationAsync(AuthorizationHandlerContext context,
+            OrderOperationAuthorizationRequirement requirement, OrderCreationResource resource)
+        {
+            if (!await IsProductsPublishedAsync(resource.Input, resource.ProductDictionary))
+            {
+                context.Fail();
+                return;
+            }
+
+            if (!await IsInventoriesSufficientAsync(resource.Input, resource.ProductDictionary))
+            {
+                context.Fail();
+                return;
+            }
+            
+            context.Succeed(requirement);
+        }
+
+        protected virtual Task<bool> IsProductsPublishedAsync(CreateOrderDto input,
+            Dictionary<Guid, ProductDto> productDictionary)
+        {
+            return Task.FromResult(
+                input.OrderLines.Select(dto => dto.ProductId).Distinct().ToArray()
+                    .All(productId => productDictionary[productId].IsPublished)
+            );
+        }
+
+        protected virtual Task<bool> IsInventoriesSufficientAsync(CreateOrderDto input,
+            Dictionary<Guid, ProductDto> productDictionary)
+        {
+            return Task.FromResult(
+                !(from orderLine in input.OrderLines
+                    let product = productDictionary[orderLine.ProductId]
+                    let inventory = product.ProductSkus.Single(sku => sku.Id == orderLine.ProductSkuId).Inventory
+                    where product.InventoryStrategy != InventoryStrategy.NoNeed && inventory < orderLine.Quantity
+                    select orderLine).Any()
+            );
+        }
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/BasicPurchasableCheckProvider.cs

@@ -1,55 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Products.Products;
-using EasyAbp.EShop.Products.Products.Dtos;
-using Volo.Abp.DependencyInjection;
-
-namespace EasyAbp.EShop.Orders.Orders
-{
-    public class BasicPurchasableCheckProvider : IPurchasableCheckProvider, ITransientDependency
-    {
-        public virtual async Task CheckAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict,
-            Dictionary<string, object> orderExtraProperties)
-        {
-            await CheckProductsPublishedAsync(input, productDict);
-
-            await CheckInventoriesSufficientAsync(input, productDict);
-        }
-
-        protected virtual Task CheckProductsPublishedAsync(CreateOrderDto input,
-            Dictionary<Guid, ProductDto> productDict)
-        {
-            foreach (var productId in input.OrderLines.Select(dto => dto.ProductId).Distinct().ToArray())
-            {
-                if (!productDict[productId].IsPublished)
-                {
-                    throw new NotPurchasableException(productId, null, "Unpublished project");
-                }
-            }
-            
-            return Task.CompletedTask;
-        }
-
-        protected virtual Task CheckInventoriesSufficientAsync(CreateOrderDto input,
-            Dictionary<Guid, ProductDto> productDict)
-        {
-            foreach (var orderLine in input.OrderLines)
-            {
-                var product = productDict[orderLine.ProductId];
-                var inventory = product.ProductSkus
-                    .Single(sku => sku.Id == orderLine.ProductSkuId).Inventory;
-
-                if (product.InventoryStrategy != InventoryStrategy.NoNeed && inventory < orderLine.Quantity)
-                {
-                    throw new NotPurchasableException(orderLine.ProductId, orderLine.ProductSkuId,
-                        "Insufficient inventory");
-                }
-            }
-            
-            return Task.CompletedTask;
-        }
-    }
-}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/CurrencyIsLimitException.cs

@@ -0,0 +1,14 @@
+using System;
+using Volo.Abp;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    public class CurrencyIsLimitException : BusinessException
+    {
+        public CurrencyIsLimitException(string expectedCurrency) : base(
+            "CurrencyIsLimit",
+            $"Only the specified currency {expectedCurrency} is allowed.")
+        {
+        }
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/INewOrderGenerator.cs

@@ -8,7 +8,6 @@ namespace EasyAbp.EShop.Orders.Orders
 {
     public interface INewOrderGenerator
     {
-        Task<Order> GenerateAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict,
-            Dictionary<string, object> orderExtraProperties);
+        Task<Order> GenerateAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict);
     }
 }

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/IPurchasableCheckProvider.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Products.Products.Dtos;
-
-namespace EasyAbp.EShop.Orders.Orders
-{
-    public interface IPurchasableCheckProvider
-    {
-        Task CheckAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict,
-            Dictionary<string, object> orderExtraProperties);
-    }
-}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/IPurchasableChecker.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Products.Products.Dtos;
-
-namespace EasyAbp.EShop.Orders.Orders
-{
-    public interface IPurchasableChecker
-    {
-        Task CheckAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict,
-            Dictionary<string, object> orderExtraProperties);
-    }
-}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/NewOrderGenerator.cs

@@ -1,17 +1,14 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
 using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Products.ProductInventories;
 using EasyAbp.EShop.Products.Products;
 using EasyAbp.EShop.Products.Products.Dtos;
-using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Guids;
-using Volo.Abp.Json;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.ObjectExtending;
 using Volo.Abp.Users;
 
 namespace EasyAbp.EShop.Orders.Orders
@@ -38,13 +35,20 @@ namespace EasyAbp.EShop.Orders.Orders
             _productSkuDescriptionProvider = productSkuDescriptionProvider;
         }
         
-        public virtual async Task<Order> GenerateAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict, Dictionary<string, object> orderExtraProperties)
+        public virtual async Task<Order> GenerateAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict)
         {
             var orderLines = new List<OrderLine>();
 
-            foreach (var orderLine in input.OrderLines)
+            foreach (var inputOrderLine in input.OrderLines)
             {
-                orderLines.Add(await GenerateOrderLineAsync(orderLine, productDict, orderExtraProperties));
+                orderLines.Add(await GenerateOrderLineAsync(input, inputOrderLine, productDict));
+            }
+
+            var storeCurrency = await GetStoreCurrencyAsync(input.StoreId);
+
+            if (orderLines.Any(x => x.Currency != storeCurrency))
+            {
+                throw new CurrencyIsLimitException(storeCurrency);
             }
 
             var productTotalPrice = orderLines.Select(x => x.TotalPrice).Sum();
@@ -58,17 +62,14 @@ namespace EasyAbp.EShop.Orders.Orders
                 tenantId: _currentTenant.Id,
                 storeId: input.StoreId,
                 customerUserId: _currentUser.GetId(),
-                currency: await GetStoreCurrencyAsync(input.StoreId),
+                currency: storeCurrency,
                 productTotalPrice: productTotalPrice,
                 totalDiscount: totalDiscount,
                 totalPrice: totalPrice,
                 actualTotalPrice: totalPrice - totalDiscount,
                 customerRemark: input.CustomerRemark);
-
-            foreach (var orderExtraProperty in orderExtraProperties)
-            {
-                order.SetProperty(orderExtraProperty.Key, orderExtraProperty.Value);
-            }
+            
+            input.MapExtraPropertiesTo(order, MappingPropertyDefinitionChecks.Destination);
 
             order.SetOrderLines(orderLines);
             
@@ -77,18 +78,19 @@ namespace EasyAbp.EShop.Orders.Orders
             return order;
         }
 
-        protected virtual async Task<OrderLine> GenerateOrderLineAsync(CreateOrderLineDto input, Dictionary<Guid, ProductDto> productDict, Dictionary<string, object> orderExtraProperties)
+        protected virtual async Task<OrderLine> GenerateOrderLineAsync(CreateOrderDto input,
+            CreateOrderLineDto inputOrderLine, Dictionary<Guid, ProductDto> productDict)
         {
-            var product = productDict[input.ProductId];
-            var productSku = product.GetSkuById(input.ProductSkuId);
+            var product = productDict[inputOrderLine.ProductId];
+            var productSku = product.GetSkuById(inputOrderLine.ProductSkuId);
 
-            if (!input.Quantity.IsBetween(productSku.OrderMinQuantity, productSku.OrderMaxQuantity))
+            if (!inputOrderLine.Quantity.IsBetween(productSku.OrderMinQuantity, productSku.OrderMaxQuantity))
             {
-                throw new OrderLineInvalidQuantityException(product.Id, productSku.Id, input.Quantity);
+                throw new OrderLineInvalidQuantityException(product.Id, productSku.Id, inputOrderLine.Quantity);
             }
-
-            var totalPrice = productSku.Price * input.Quantity;
             
+            var totalPrice = productSku.Price * inputOrderLine.Quantity;
+
             return new OrderLine(
                 id: _guidGenerator.Create(),
                 productId: product.Id,
@@ -107,7 +109,7 @@ namespace EasyAbp.EShop.Orders.Orders
                 totalPrice: totalPrice,
                 totalDiscount: 0,
                 actualTotalPrice: totalPrice,
-                quantity: input.Quantity
+                quantity: inputOrderLine.Quantity
             );
         }
 

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/NotPurchasableException.cs

@@ -1,13 +0,0 @@
-using System;
-using Volo.Abp;
-
-namespace EasyAbp.EShop.Orders.Orders
-{
-    public class NotPurchasableException : BusinessException
-    {
-        public NotPurchasableException(Guid productId, Guid? productSkuId, string reason) : base(
-            message: $"Product {productId} (SKU: {productSkuId}) cannot be purchased, the reason is: {reason}")
-        {
-        }
-    }
-}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/OrderAppService.cs

@@ -6,13 +6,10 @@ using EasyAbp.EShop.Orders.Authorization;
 using EasyAbp.EShop.Orders.Orders.Dtos;
 using EasyAbp.EShop.Products.Products;
 using EasyAbp.EShop.Products.Products.Dtos;
-using EasyAbp.EShop.Stores.Authorization;
 using EasyAbp.EShop.Stores.Stores;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.Application.Services;
-using Volo.Abp.Authorization;
 using Volo.Abp.Users;
 
 namespace EasyAbp.EShop.Orders.Orders
@@ -28,20 +25,17 @@ namespace EasyAbp.EShop.Orders.Orders
 
         private readonly INewOrderGenerator _newOrderGenerator;
         private readonly IProductAppService _productAppService;
-        private readonly IPurchasableChecker _purchasableChecker;
         private readonly IOrderManager _orderManager;
         private readonly IOrderRepository _repository;
 
         public OrderAppService(
             INewOrderGenerator newOrderGenerator,
             IProductAppService productAppService,
-            IPurchasableChecker purchasableChecker,
             IOrderManager orderManager,
             IOrderRepository repository) : base(repository)
         {
             _newOrderGenerator = newOrderGenerator;
             _productAppService = productAppService;
-            _purchasableChecker = purchasableChecker;
             _orderManager = orderManager;
             _repository = repository;
         }
@@ -87,18 +81,23 @@ namespace EasyAbp.EShop.Orders.Orders
 
         public override async Task<OrderDto> CreateAsync(CreateOrderDto input)
         {
-            await CheckMultiStorePolicyAsync(input.StoreId, CreatePolicyName);
+            await CheckCreatePolicyAsync();
 
             // Todo: Check if the store is open.
 
             var productDict = await GetProductDictionaryAsync(input.OrderLines.Select(dto => dto.ProductId).ToList(),
                 input.StoreId);
 
-            var orderExtraProperties = new Dictionary<string, object>();
+            await AuthorizationService.CheckAsync(
+                new OrderCreationResource
+                {
+                    Input = input,
+                    ProductDictionary = productDict
+                },
+                new OrderOperationAuthorizationRequirement(OrderOperation.Creation)
+            );
 
-            await _purchasableChecker.CheckAsync(input, productDict, orderExtraProperties);
-
-            var order = await _newOrderGenerator.GenerateAsync(input, productDict, orderExtraProperties);
+            var order = await _newOrderGenerator.GenerateAsync(input, productDict);
 
             await _orderManager.DiscountAsync(order, input.ExtraProperties);
 
@@ -134,6 +133,8 @@ namespace EasyAbp.EShop.Orders.Orders
 
         public virtual async Task<OrderDto> GetByOrderNumberAsync(string orderNumber)
         {
+            await CheckGetPolicyAsync();
+
             var order = await _repository.GetAsync(x => x.OrderNumber == orderNumber);
 
             if (order.CustomerUserId != CurrentUser.GetId())

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/OrderCreationAuthorizationHandler.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    public abstract class OrderCreationAuthorizationHandler : AuthorizationHandler<OrderOperationAuthorizationRequirement, OrderCreationResource>
+    {
+        protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OrderOperationAuthorizationRequirement requirement,
+            OrderCreationResource resource)
+        {
+            if (requirement.OrderOperation != OrderOperation.Creation)
+            {
+                return;
+            }
+            
+            await HandleOrderCreationAsync(context, requirement, resource);
+        }
+
+        protected abstract Task HandleOrderCreationAsync(AuthorizationHandlerContext context,
+            OrderOperationAuthorizationRequirement requirement, OrderCreationResource resource);
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/OrderCreationResource.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using EasyAbp.EShop.Orders.Orders.Dtos;
+using EasyAbp.EShop.Products.Products.Dtos;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    public class OrderCreationResource
+    {
+        public CreateOrderDto Input { get; set; }
+        
+        public Dictionary<Guid, ProductDto> ProductDictionary { get; set; }
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/OrderOperation.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    [Flags]
+    public enum OrderOperation
+    {
+        Creation = 0
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/OrderOperationAuthorizationRequirement.cs

@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Orders.Orders
+{
+    public class OrderOperationAuthorizationRequirement : IAuthorizationRequirement
+    {
+        public OrderOperation OrderOperation { get; }
+        
+        public OrderOperationAuthorizationRequirement(OrderOperation orderOperation)
+        {
+            OrderOperation = orderOperation;
+        }
+    }
+}

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Application/EasyAbp/EShop/Orders/Orders/PurchasableChecker.cs

@@ -1,31 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Products.Products.Dtos;
-using Microsoft.Extensions.DependencyInjection;
-using Volo.Abp.DependencyInjection;
-
-namespace EasyAbp.EShop.Orders.Orders
-{
-    public class PurchasableChecker : IPurchasableChecker, ITransientDependency
-    {
-        private readonly IServiceProvider _serviceProvider;
-
-        public PurchasableChecker(IServiceProvider serviceProvider)
-        {
-            _serviceProvider = serviceProvider;
-        }
-
-        public virtual async Task CheckAsync(CreateOrderDto input, Dictionary<Guid, ProductDto> productDict,
-            Dictionary<string, object> orderExtraProperties)
-        {
-            var providers = _serviceProvider.GetServices<IPurchasableCheckProvider>();
-
-            foreach (var provider in providers)
-            {
-                await provider.CheckAsync(input, productDict, orderExtraProperties);
-            }
-        }
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application.Contracts/EasyAbp/EShop/Payments/Payments/PaymentAlreadyExistsException.cs

@@ -1,13 +0,0 @@
-using System;
-using Volo.Abp;
-
-namespace EasyAbp.EShop.Payments.Payments
-{
-    public class PaymentAlreadyExistsException : BusinessException
-    {
-        public PaymentAlreadyExistsException(Guid orderId)
-            : base(message: $"The order {orderId}'s payment is already exists.")
-        {
-        }
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/EShopPaymentsApplicationModule.cs

@@ -1,4 +1,5 @@
-using EasyAbp.PaymentService;
+using EasyAbp.EShop.Payments.Payments;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.AutoMapper;
 using Volo.Abp.Modularity;
@@ -14,6 +15,11 @@ namespace EasyAbp.EShop.Payments
         )]
     public class EShopPaymentsApplicationModule : AbpModule
     {
+        public override void PreConfigureServices(ServiceConfigurationContext context)
+        {
+            context.Services.AddSingleton<IAuthorizationHandler, BasicPaymentCreationAuthorizationHandler>();
+        }
+
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
             context.Services.AddAutoMapperObjectMapper<EShopPaymentsApplicationModule>();

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/BasicPayableCheckProvider.cs

@@ -1,29 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Payments.Payments.Dtos;
-using EasyAbp.PaymentService.Payments;
-using Volo.Abp.DependencyInjection;
-
-namespace EasyAbp.EShop.Payments.Payments
-{
-    public class BasicPayableCheckProvider : IPayableCheckProvider, ITransientDependency
-    {
-        public virtual Task CheckAsync(CreatePaymentDto input, List<OrderDto> orders, CreatePaymentEto createPaymentEto)
-        {
-            foreach (var order in orders.Where(order => order.PaymentId.HasValue || order.PaidTime.HasValue))
-            {
-                throw new PaymentAlreadyExistsException(order.Id);
-            }
-
-            if (orders.Select(order => order.Currency).Distinct().Count() != 1)
-            {
-                // Todo: convert to a single currency.
-                throw new MultiCurrencyNotSupportedException();
-            }
-
-            return Task.CompletedTask;
-        }
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/BasicPaymentCreationAuthorizationHandler.cs

@@ -0,0 +1,34 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Payments.Payments
+{
+    public class BasicPaymentCreationAuthorizationHandler : PaymentCreationAuthorizationHandler
+    {
+
+        public BasicPaymentCreationAuthorizationHandler()
+        {
+        }
+        
+        protected override Task HandlePaymentCreationAsync(AuthorizationHandlerContext context,
+            PaymentOperationAuthorizationRequirement requirement, PaymentCreationResource resource)
+        {
+            if (resource.Orders.Any(order => order.PaymentId.HasValue || order.PaidTime.HasValue))
+            {
+                context.Fail();
+                return Task.CompletedTask;
+            }
+
+            if (resource.Orders.Select(order => order.Currency).Distinct().Count() != 1)
+            {
+                // Todo: convert to a single currency.
+                context.Fail();
+                return Task.CompletedTask;
+            }
+
+            context.Succeed(requirement);
+            return Task.CompletedTask;
+        }
+    }
+}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/IPayableChecker.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Payments.Payments.Dtos;
-using EasyAbp.PaymentService.Payments;
-
-namespace EasyAbp.EShop.Payments.Payments
-{
-    public interface IPayableChecker
-    {
-        Task CheckAsync(CreatePaymentDto input, List<OrderDto> orders, CreatePaymentEto createPaymentEto);
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/MultiCurrencyNotSupportedException.cs

@@ -1,12 +0,0 @@
-using Volo.Abp;
-
-namespace EasyAbp.EShop.Payments.Payments
-{
-    public class MultiCurrencyNotSupportedException : BusinessException
-    {
-        public MultiCurrencyNotSupportedException() : base(message: $"The currency of all orders should be the same.")
-        {
-            
-        }
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PayableChecker.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using EasyAbp.EShop.Orders.Orders.Dtos;
-using EasyAbp.EShop.Payments.Payments.Dtos;
-using EasyAbp.PaymentService.Payments;
-using Microsoft.Extensions.DependencyInjection;
-using Volo.Abp.DependencyInjection;
-
-namespace EasyAbp.EShop.Payments.Payments
-{
-    public class PayableChecker : IPayableChecker, ITransientDependency
-    {
-        private readonly IServiceProvider _serviceProvider;
-
-        public PayableChecker(IServiceProvider serviceProvider)
-        {
-            _serviceProvider = serviceProvider;
-        }
-
-
-        public virtual async Task CheckAsync(CreatePaymentDto input, List<OrderDto> orders, CreatePaymentEto createPaymentEto)
-        {
-            var providers = _serviceProvider.GetServices<IPayableCheckProvider>();
-
-            foreach (var provider in providers)
-            {
-                await provider.CheckAsync(input, orders, createPaymentEto);
-            }
-        }
-    }
-}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PaymentAppService.cs

@@ -2,14 +2,12 @@ using EasyAbp.EShop.Orders.Orders;
 using EasyAbp.EShop.Orders.Orders.Dtos;
 using EasyAbp.EShop.Payments.Authorization;
 using EasyAbp.EShop.Payments.Payments.Dtos;
-using EasyAbp.EShop.Stores.Permissions;
 using EasyAbp.PaymentService.Payments;
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using EasyAbp.EShop.Stores.Stores;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Application.Services;
 using Volo.Abp.EventBus.Distributed;
@@ -24,18 +22,15 @@ namespace EasyAbp.EShop.Payments.Payments
         protected override string GetPolicyName { get; set; } = PaymentsPermissions.Payments.Manage;
         protected override string GetListPolicyName { get; set; } = PaymentsPermissions.Payments.Manage;
 
-        private readonly IPayableChecker _payableChecker;
         private readonly IDistributedEventBus _distributedEventBus;
         private readonly IOrderAppService _orderAppService;
         private readonly IPaymentRepository _repository;
         
         public PaymentAppService(
-            IPayableChecker payableChecker,
             IDistributedEventBus distributedEventBus,
             IOrderAppService orderAppService,
             IPaymentRepository repository) : base(repository)
         {
-            _payableChecker = payableChecker;
             _distributedEventBus = distributedEventBus;
             _orderAppService = orderAppService;
             _repository = repository;
@@ -88,6 +83,15 @@ namespace EasyAbp.EShop.Payments.Payments
             {
                 orders.Add(await _orderAppService.GetAsync(orderId));
             }
+            
+            await AuthorizationService.CheckAsync(
+                new PaymentCreationResource
+                {
+                    Input = input,
+                    Orders = orders
+                },
+                new PaymentOperationAuthorizationRequirement(PaymentOperation.Creation)
+            );
 
             var createPaymentEto = new CreatePaymentEto
             {
@@ -105,8 +109,6 @@ namespace EasyAbp.EShop.Payments.Payments
                 }).ToList()
             };
 
-            await _payableChecker.CheckAsync(input, orders, createPaymentEto);
-            
             await _distributedEventBus.PublishAsync(createPaymentEto);
         }
     }

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PaymentCreationAuthorizationHandler.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Payments.Payments
+{
+    public abstract class PaymentCreationAuthorizationHandler : AuthorizationHandler<PaymentOperationAuthorizationRequirement, PaymentCreationResource>
+    {
+        protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PaymentOperationAuthorizationRequirement requirement,
+            PaymentCreationResource resource)
+        {
+            if (requirement.PaymentOperation != PaymentOperation.Creation)
+            {
+                return;
+            }
+            
+            await HandlePaymentCreationAsync(context, requirement, resource);
+        }
+
+        protected abstract Task HandlePaymentCreationAsync(AuthorizationHandlerContext context,
+            PaymentOperationAuthorizationRequirement requirement, PaymentCreationResource resource);
+    }
+}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/IPayableCheckProvider.cs → modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PaymentCreationResource.cs

@@ -1,13 +1,14 @@
 using System.Collections.Generic;
-using System.Threading.Tasks;
 using EasyAbp.EShop.Orders.Orders.Dtos;
 using EasyAbp.EShop.Payments.Payments.Dtos;
 using EasyAbp.PaymentService.Payments;
 
 namespace EasyAbp.EShop.Payments.Payments
 {
-    public interface IPayableCheckProvider
+    public class PaymentCreationResource
     {
-        Task CheckAsync(CreatePaymentDto input, List<OrderDto> orders, CreatePaymentEto createPaymentEto);
+        public CreatePaymentDto Input { get; set; }
+        
+        public List<OrderDto> Orders { get; set; }
     }
 }

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PaymentOperation.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace EasyAbp.EShop.Payments.Payments
+{
+    [Flags]
+    public enum PaymentOperation
+    {
+        Creation = 0
+    }
+}

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Payments/PaymentOperationAuthorizationRequirement.cs

@@ -0,0 +1,15 @@
+using JetBrains.Annotations;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EasyAbp.EShop.Payments.Payments
+{
+    public class PaymentOperationAuthorizationRequirement : IAuthorizationRequirement
+    {
+        public PaymentOperation PaymentOperation { get; }
+        
+        public PaymentOperationAuthorizationRequirement(PaymentOperation paymentOperation)
+        {
+            PaymentOperation = paymentOperation;
+        }
+    }
+}

modules/EasyAbp.EShop.Stores/src/EasyAbp.EShop.Stores.Application.Shared/EasyAbp/EShop/Stores/EShopStoresApplicationSharedModule.cs

@@ -14,7 +14,7 @@ namespace EasyAbp.EShop.Stores
     )]
     public class EShopStoresApplicationSharedModule : AbpModule
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        public override void PreConfigureServices(ServiceConfigurationContext context)
         {
             context.Services.AddSingleton<IAuthorizationHandler, BasicStorePermissionAuthorizationHandler>();
         }