Rename properties in RefundItem

Improve extra properties usage
Add missing OrderExtraFees in RefundItemDto
Upgrade PaymentService module to 2.0.9

Directory.Build.props

@@ -3,7 +3,7 @@
 
     <AbpVersion>5.1.3</AbpVersion>
     <EasyAbpAbpTreesModuleVersion>2.5.3</EasyAbpAbpTreesModuleVersion>
-    <EasyAbpPaymentServiceModuleVersion>2.0.7</EasyAbpPaymentServiceModuleVersion>
+    <EasyAbpPaymentServiceModuleVersion>2.0.9</EasyAbpPaymentServiceModuleVersion>
     <EasyAbpAbpTagHelperPlusModuleVersion>0.8.2</EasyAbpAbpTagHelperPlusModuleVersion>
 
   </PropertyGroup>

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Domain/EasyAbp/EShop/Orders/Orders/OrderPaymentChecker.cs

@@ -1,7 +1,5 @@
-using System;
 using System.Threading.Tasks;
 using EasyAbp.EShop.Payments.Payments;
-using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 
 namespace EasyAbp.EShop.Orders.Orders
@@ -17,9 +15,7 @@ namespace EasyAbp.EShop.Orders.Orders
         
         protected virtual Task<bool> IsStoreIdCorrectAsync(Order order, EShopPaymentItemEto paymentItem)
         {
-            return Task.FromResult(
-                Guid.TryParse(paymentItem.GetProperty<string>("StoreId"), out var paymentStoreId) &&
-                order.StoreId == paymentStoreId);
+            return Task.FromResult(order.StoreId == paymentItem.StoreId);
         }
         
         protected virtual Task<bool> IsPaymentPriceCorrectAsync(Order order, EShopPaymentItemEto paymentItem)

modules/EasyAbp.EShop.Orders/src/EasyAbp.EShop.Orders.Domain/EasyAbp/EShop/Orders/Orders/RefundCompletedEventHandler.cs

@@ -1,7 +1,6 @@
 using System.Threading.Tasks;
 using EasyAbp.EShop.Payments.Refunds;
 using Volo.Abp.DependencyInjection;
-using Volo.Abp.Domain.Entities.Events.Distributed;
 using Volo.Abp.EventBus.Distributed;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.ObjectMapping;
@@ -38,12 +37,12 @@ namespace EasyAbp.EShop.Orders.Orders
                 // Todo: what if Order.PaymentId != eventData.Refund.PaymentId?
                 var order = await _orderRepository.GetAsync(refundItem.OrderId);
 
-                foreach (var eto in refundItem.RefundItemOrderLines)
+                foreach (var eto in refundItem.OrderLines)
                 {
                     order.RefundOrderLine(eto.OrderLineId, eto.RefundedQuantity, eto.RefundAmount);
                 }
 
-                foreach (var eto in refundItem.RefundItemOrderExtraFees)
+                foreach (var eto in refundItem.OrderExtraFees)
                 {
                     order.RefundOrderExtraFee(eto.Name, eto.Key, eto.RefundAmount);
                 }

modules/EasyAbp.EShop.Orders/test/EasyAbp.EShop.Orders.Domain.Tests/Orders/OrderDomainTests.cs

@@ -93,7 +93,7 @@ namespace EasyAbp.EShop.Orders.Orders
                             RefundAmount = 0.3m,
                             StoreId = OrderTestData.Store1Id,
                             OrderId = OrderTestData.Order1Id,
-                            RefundItemOrderLines = new List<RefundItemOrderLineEto>
+                            OrderLines = new List<RefundItemOrderLineEto>
                             {
                                 new()
                                 {
@@ -102,7 +102,7 @@ namespace EasyAbp.EShop.Orders.Orders
                                     RefundAmount = 0.2m
                                 }
                             },
-                            RefundItemOrderExtraFees = new List<RefundItemOrderExtraFeeEto>
+                            OrderExtraFees = new List<RefundItemOrderExtraFeeEto>
                             {
                                 new()
                                 {
@@ -151,7 +151,7 @@ namespace EasyAbp.EShop.Orders.Orders
                                 RefundAmount = -1m,
                                 StoreId = OrderTestData.Store1Id,
                                 OrderId = OrderTestData.Order1Id,
-                                RefundItemOrderLines = new List<RefundItemOrderLineEto>
+                                OrderLines = new List<RefundItemOrderLineEto>
                                 {
                                     new()
                                     {
@@ -192,7 +192,7 @@ namespace EasyAbp.EShop.Orders.Orders
                                 RefundAmount = 0.3m,
                                 StoreId = OrderTestData.Store1Id,
                                 OrderId = OrderTestData.Order1Id,
-                                RefundItemOrderLines = new List<RefundItemOrderLineEto>
+                                OrderLines = new List<RefundItemOrderLineEto>
                                 {
                                     new()
                                     {

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application.Contracts/EasyAbp/EShop/Payments/Refunds/Dtos/RefundItemDto.cs

@@ -24,6 +24,8 @@ namespace EasyAbp.EShop.Payments.Refunds.Dtos
         
         public Guid OrderId { get; set; }
         
-        public List<RefundItemOrderLineDto> RefundItemOrderLines { get; set; }
+        public List<RefundItemOrderLineDto> OrderLines { get; set; }
+        
+        public List<RefundItemOrderExtraFeeEto> OrderExtraFees { get; set; }
     }
 }

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

@@ -105,7 +105,7 @@ namespace EasyAbp.EShop.Payments.Payments
                     OriginalPaymentAmount = order.ActualTotalPrice
                 };
                 
-                eto.SetProperty("StoreId", order.StoreId.ToString());
+                eto.SetProperty(nameof(PaymentItem.StoreId), order.StoreId);
 
                 return eto;
             }).ToList();

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Application/EasyAbp/EShop/Payments/Refunds/RefundAppService.cs

@@ -153,10 +153,10 @@ namespace EasyAbp.EShop.Payments.Refunds
                     StaffRemark = refundItem.StaffRemark
                 };
 
-                eto.SetProperty("StoreId", order.StoreId.ToString());
-                eto.SetProperty("OrderId", order.Id.ToString());
-                eto.SetProperty("OrderLines", _jsonSerializer.Serialize(refundItem.OrderLines));
-                eto.SetProperty("OrderExtraFees", _jsonSerializer.Serialize(refundItem.OrderExtraFees));
+                eto.SetProperty(nameof(RefundItem.StoreId), order.StoreId);
+                eto.SetProperty(nameof(RefundItem.OrderId), order.Id);
+                eto.SetProperty(nameof(RefundItem.OrderLines), _jsonSerializer.Serialize(refundItem.OrderLines));
+                eto.SetProperty(nameof(RefundItem.OrderExtraFees), _jsonSerializer.Serialize(refundItem.OrderExtraFees));
 
                 createRefundInput.RefundItems.Add(eto);
             }

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Domain.Shared/EasyAbp/EShop/Payments/Refunds/EShopRefundItemEto.cs

@@ -26,8 +26,8 @@ namespace EasyAbp.EShop.Payments.Refunds
         
         public Guid OrderId { get; set; }
         
-        public List<RefundItemOrderLineEto> RefundItemOrderLines { get; set; } = new();
+        public List<RefundItemOrderLineEto> OrderLines { get; set; } = new();
         
-        public List<RefundItemOrderExtraFeeEto> RefundItemOrderExtraFees { get; set; } = new();
+        public List<RefundItemOrderExtraFeeEto> OrderExtraFees { get; set; } = new();
     }
 }

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Domain/EasyAbp/EShop/Payments/Payments/PaymentSynchronizer.cs

@@ -146,12 +146,14 @@ namespace EasyAbp.EShop.Payments.Payments
 
         protected virtual void FillPaymentItemStoreId(PaymentItem item)
         {
-            if (!Guid.TryParse(item.GetProperty<string>("StoreId"), out var storeId))
+            var storeId = item.GetProperty<Guid?>(nameof(PaymentItem.StoreId));
+            
+            if (storeId is null)
             {
                 throw new StoreIdNotFoundException();
             }
             
-            item.SetStoreId(storeId);
+            item.SetStoreId(storeId.Value);
         }
 
         [UnitOfWork(true)]

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Domain/EasyAbp/EShop/Payments/Refunds/RefundItem.cs

@@ -29,14 +29,14 @@ namespace EasyAbp.EShop.Payments.Refunds
         
         public virtual Guid OrderId { get; protected set; }
         
-        public virtual List<RefundItemOrderLine> RefundItemOrderLines { get; protected set; }
+        public virtual List<RefundItemOrderLine> OrderLines { get; protected set; }
         
-        public virtual List<RefundItemOrderExtraFee> RefundItemOrderExtraFees { get; protected set; }
+        public virtual List<RefundItemOrderExtraFee> OrderExtraFees { get; protected set; }
 
         protected RefundItem()
         {
-            RefundItemOrderLines = new List<RefundItemOrderLine>();
-            RefundItemOrderExtraFees = new List<RefundItemOrderExtraFee>();
+            OrderLines = new List<RefundItemOrderLine>();
+            OrderExtraFees = new List<RefundItemOrderExtraFee>();
             
             ExtraProperties = new ExtraPropertyDictionary();
             

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.Domain/EasyAbp/EShop/Payments/Refunds/RefundSynchronizer.cs

@@ -152,12 +152,12 @@ namespace EasyAbp.EShop.Payments.Refunds
             {
                 var orderLineInfoModels =
                     _jsonSerializer.Deserialize<List<OrderLineRefundInfoModel>>(
-                        refundItem.GetProperty<string>("OrderLines"));
+                        refundItem.GetProperty<string>(nameof(RefundItem.OrderLines)));
                 
                 foreach (var orderLineInfoModel in orderLineInfoModels)
                 {
                     var refundItemOrderLineEntity =
-                        refundItem.RefundItemOrderLines.FirstOrDefault(x =>
+                        refundItem.OrderLines.FirstOrDefault(x =>
                             x.OrderLineId == orderLineInfoModel.OrderLineId);
 
                     if (refundItemOrderLineEntity == null)
@@ -166,12 +166,12 @@ namespace EasyAbp.EShop.Payments.Refunds
                             orderLineInfoModel.OrderLineId, orderLineInfoModel.Quantity,
                             orderLineInfoModel.TotalAmount);
                         
-                        refundItem.RefundItemOrderLines.Add(refundItemOrderLineEntity);
+                        refundItem.OrderLines.Add(refundItemOrderLineEntity);
                     }
 
                     var orderLineIds = orderLineInfoModels.Select(i => i.OrderLineId).ToList();
 
-                    refundItem.RefundItemOrderLines.RemoveAll(i => !orderLineIds.Contains(i.OrderLineId));
+                    refundItem.OrderLines.RemoveAll(i => !orderLineIds.Contains(i.OrderLineId));
                 }
             }
         }
@@ -182,12 +182,12 @@ namespace EasyAbp.EShop.Payments.Refunds
             {
                 var orderExtraFeeInfoModels =
                     _jsonSerializer.Deserialize<List<OrderExtraFeeRefundInfoModel>>(
-                        refundItem.GetProperty<string>("OrderExtraFees"));
+                        refundItem.GetProperty<string>(nameof(RefundItem.OrderExtraFees)));
                 
                 foreach (var orderExtraFeeInfoModel in orderExtraFeeInfoModels)
                 {
                     var refundItemOrderExtraFeeEntity =
-                        refundItem.RefundItemOrderExtraFees.FirstOrDefault(x =>
+                        refundItem.OrderExtraFees.FirstOrDefault(x =>
                             x.Name == orderExtraFeeInfoModel.Name &&
                             x.Key == orderExtraFeeInfoModel.Key);
 
@@ -197,12 +197,12 @@ namespace EasyAbp.EShop.Payments.Refunds
                             orderExtraFeeInfoModel.Name, orderExtraFeeInfoModel.Key,
                             orderExtraFeeInfoModel.TotalAmount);
                         
-                        refundItem.RefundItemOrderExtraFees.Add(refundItemOrderExtraFeeEntity);
+                        refundItem.OrderExtraFees.Add(refundItemOrderExtraFeeEntity);
                     }
 
                     var orderExtraFeeIds = orderExtraFeeInfoModels.Select(i => new { i.Name, i.Key }).ToList();
 
-                    refundItem.RefundItemOrderExtraFees.RemoveAll(
+                    refundItem.OrderExtraFees.RemoveAll(
                         i => !orderExtraFeeIds.Contains(new { i.Name, i.Key }));
                 }
             }
@@ -210,22 +210,24 @@ namespace EasyAbp.EShop.Payments.Refunds
 
         protected virtual void FillRefundItemStoreId(RefundItem item)
         {
-            if (!Guid.TryParse(item.GetProperty<string>("StoreId"), out var storeId))
+            var storeId = item.GetProperty<Guid?>(nameof(RefundItem.StoreId));
+            if (storeId is null)
             {
                 throw new StoreIdNotFoundException();
             }
                     
-            item.SetStoreId(storeId);
+            item.SetStoreId(storeId.Value);
         }
         
         protected virtual void FillRefundItemOrderId(RefundItem item)
         {
-            if (!Guid.TryParse(item.GetProperty<string>("OrderId"), out var orderId))
+            var orderId = item.GetProperty<Guid?>(nameof(RefundItem.OrderId));
+            if (orderId is null)
             {
                 throw new OrderIdNotFoundException();
             }
             
-            item.SetOrderId(orderId);
+            item.SetOrderId(orderId.Value);
         }
         
         [UnitOfWork(true)]

modules/EasyAbp.EShop.Payments/src/EasyAbp.EShop.Payments.EntityFrameworkCore/EasyAbp/EShop/Payments/Refunds/RefundRepository.cs

@@ -18,9 +18,9 @@ namespace EasyAbp.EShop.Payments.Refunds
         {
             return (await base.WithDetailsAsync())
                 .Include(x => x.RefundItems)
-                    .ThenInclude(x => x.RefundItemOrderLines)
+                    .ThenInclude(x => x.OrderLines)
                 .Include(x => x.RefundItems)
-                    .ThenInclude(x => x.RefundItemOrderExtraFees);
+                    .ThenInclude(x => x.OrderExtraFees);
         }
 
         public virtual async Task<IQueryable<Refund>> GetQueryableByUserIdAsync(Guid userId)

modules/EasyAbp.EShop.Payments/test/EasyAbp.EShop.Payments.Application.Tests/Refunds/RefundAppServiceTests.cs

@@ -1,15 +1,20 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using EasyAbp.EShop.Orders.Orders;
 using EasyAbp.EShop.Orders.Orders.Dtos;
 using EasyAbp.EShop.Payments.Payments;
 using EasyAbp.EShop.Payments.Refunds.Dtos;
+using EasyAbp.PaymentService.Refunds;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
+using NSubstitute.Core;
 using Shouldly;
 using Volo.Abp.Data;
+using Volo.Abp.Domain.Entities.Events.Distributed;
 using Volo.Abp.Json;
+using Volo.Abp.Uow;
 using Volo.Abp.Validation;
 using Xunit;
 
@@ -30,8 +35,8 @@ namespace EasyAbp.EShop.Payments.Refunds
         private void MockPaymentRepository(IServiceCollection services)
         {
             var paymentRepository = Substitute.For<IPaymentRepository>();
-            
-            paymentRepository.GetAsync(PaymentsTestData.Payment1).Returns(x =>
+
+            var payment1Returns = (CallInfo _) =>
             {
                 var paymentType = typeof(Payment);
                 var paymentItemType = typeof(PaymentItem);
@@ -42,7 +47,7 @@ namespace EasyAbp.EShop.Payments.Refunds
                 paymentItemType.GetProperty(nameof(PaymentItem.ActualPaymentAmount))?.SetValue(paymentItem, 1m);
                 paymentItemType.GetProperty(nameof(PaymentItem.ItemType))?.SetValue(paymentItem, PaymentsConsts.PaymentItemType);
                 paymentItemType.GetProperty(nameof(PaymentItem.ItemKey))?.SetValue(paymentItem, PaymentsTestData.Order1.ToString());
-                paymentItem.ExtraProperties.Add("StoreId", PaymentsTestData.Store1.ToString());
+                paymentItem.ExtraProperties.Add(nameof(paymentItem.StoreId), PaymentsTestData.Store1);
 
                 var payment = Activator.CreateInstance(paymentType, true) as Payment;
                 payment.ShouldNotBeNull();
@@ -52,22 +57,25 @@ namespace EasyAbp.EShop.Payments.Refunds
                 paymentType.GetProperty(nameof(Payment.PaymentItems))?.SetValue(payment, new List<PaymentItem> {paymentItem});
 
                 return payment;
-            });
-            
-            paymentRepository.GetAsync(PaymentsTestData.Payment2).Returns(x =>
+            };
+
+            var payment2Returns = (CallInfo _) =>
             {
                 var paymentType = typeof(Payment);
                 var paymentItemType = typeof(PaymentItem);
-                
+
                 var paymentItem = Activator.CreateInstance(paymentItemType, true) as PaymentItem;
                 paymentItem.ShouldNotBeNull();
-                paymentItemType.GetProperty(nameof(PaymentItem.Id))?.SetValue(paymentItem, PaymentsTestData.PaymentItem1);
+                paymentItemType.GetProperty(nameof(PaymentItem.Id))
+                    ?.SetValue(paymentItem, PaymentsTestData.PaymentItem1);
                 paymentItemType.GetProperty(nameof(PaymentItem.ActualPaymentAmount))?.SetValue(paymentItem, 1m);
                 // pending refund amount
                 paymentItemType.GetProperty(nameof(PaymentItem.PendingRefundAmount))?.SetValue(paymentItem, 1m);
-                paymentItemType.GetProperty(nameof(PaymentItem.ItemType))?.SetValue(paymentItem, PaymentsConsts.PaymentItemType);
-                paymentItemType.GetProperty(nameof(PaymentItem.ItemKey))?.SetValue(paymentItem, PaymentsTestData.Order1.ToString());
-                paymentItem.ExtraProperties.Add("StoreId", PaymentsTestData.Store1.ToString());
+                paymentItemType.GetProperty(nameof(PaymentItem.ItemType))
+                    ?.SetValue(paymentItem, PaymentsConsts.PaymentItemType);
+                paymentItemType.GetProperty(nameof(PaymentItem.ItemKey))
+                    ?.SetValue(paymentItem, PaymentsTestData.Order1.ToString());
+                paymentItem.ExtraProperties.Add(nameof(paymentItem.StoreId), PaymentsTestData.Store1);
 
                 var payment = Activator.CreateInstance(paymentType, true) as Payment;
                 payment.ShouldNotBeNull();
@@ -76,10 +84,17 @@ namespace EasyAbp.EShop.Payments.Refunds
                 paymentType.GetProperty(nameof(Payment.ActualPaymentAmount))?.SetValue(payment, 1m);
                 // pending refund amount
                 paymentType.GetProperty(nameof(Payment.PendingRefundAmount))?.SetValue(payment, 1m);
-                paymentType.GetProperty(nameof(Payment.PaymentItems))?.SetValue(payment, new List<PaymentItem> {paymentItem});
+                paymentType.GetProperty(nameof(Payment.PaymentItems))
+                    ?.SetValue(payment, new List<PaymentItem> { paymentItem });
 
                 return payment;
-            });
+            };
+
+            paymentRepository.GetAsync(PaymentsTestData.Payment1).Returns(payment1Returns);
+            paymentRepository.FindAsync(PaymentsTestData.Payment1).Returns(payment1Returns);
+            
+            paymentRepository.GetAsync(PaymentsTestData.Payment2).Returns(payment2Returns);
+            paymentRepository.FindAsync(PaymentsTestData.Payment2).Returns(payment2Returns);
             
             services.AddTransient(_ => paymentRepository);
         }
@@ -175,11 +190,11 @@ namespace EasyAbp.EShop.Payments.Refunds
             eventData.CreateRefundInput.RefundItems.Count.ShouldBe(1);
             
             var refundItem = eventData.CreateRefundInput.RefundItems[0];
-            refundItem.GetProperty<Guid>("OrderId").ShouldBe(PaymentsTestData.Order1);
+            refundItem.GetProperty<Guid?>(nameof(RefundItem.OrderId)).ShouldBe(PaymentsTestData.Order1);
 
             var orderLines =
                 _jsonSerializer.Deserialize<List<OrderLineRefundInfoModel>>(
-                    refundItem.GetProperty<string>("OrderLines"));
+                    refundItem.GetProperty<string>(nameof(RefundItem.OrderLines)));
 
             orderLines.Count.ShouldBe(1);
             orderLines[0].OrderLineId.ShouldBe(PaymentsTestData.OrderLine1);
@@ -188,7 +203,7 @@ namespace EasyAbp.EShop.Payments.Refunds
             
             var orderExtraFees =
                 _jsonSerializer.Deserialize<List<OrderExtraFeeRefundInfoModel>>(
-                    refundItem.GetProperty<string>("OrderExtraFees"));
+                    refundItem.GetProperty<string>(nameof(RefundItem.OrderExtraFees)));
             
             orderExtraFees.Count.ShouldBe(1);
             orderExtraFees[0].Name.ShouldBe("Name");
@@ -413,5 +428,94 @@ namespace EasyAbp.EShop.Payments.Refunds
                 await _refundAppService.CreateAsync(request);
             }, "RefundAmount should be greater than 0.");
         }
+
+        [Fact]
+        [UnitOfWork]
+        public virtual async Task Should_Sync_A_Refund_From_RefundEto()
+        {
+            var synchronizer = ServiceProvider.GetRequiredService<RefundSynchronizer>();
+
+            var refundItem = new RefundItemEto
+            {
+                Id = PaymentsTestData.RefundItem1,
+                PaymentItemId = PaymentsTestData.PaymentItem1,
+                RefundAmount = 1.5m,
+                CustomerRemark = "CustomerRemark1",
+                StaffRemark = "StaffRemark1"
+            };
+
+            var now = DateTime.Now;
+            
+            refundItem.SetProperty(nameof(RefundItem.StoreId), PaymentsTestData.Store1);
+            refundItem.SetProperty(nameof(RefundItem.OrderId), PaymentsTestData.Order1);
+            refundItem.SetProperty(nameof(RefundItem.OrderLines), _jsonSerializer.Serialize(new List<OrderLineRefundInfoModel>
+            {
+                new()
+                {
+                    OrderLineId = PaymentsTestData.OrderLine1,
+                    Quantity = 2,
+                    TotalAmount = 1m
+                }
+            }));
+            refundItem.SetProperty(nameof(RefundItem.OrderExtraFees), _jsonSerializer.Serialize(new List<OrderExtraFeeRefundInfoModel>
+            {
+                new()
+                {
+                    Name = "Name",
+                    Key = "Key",
+                    TotalAmount = 0.5m
+                }
+            }));
+
+            await synchronizer.HandleEventAsync(new EntityCreatedEto<RefundEto>(new RefundEto
+            {
+                Id = PaymentsTestData.Refund1,
+                TenantId = null,
+                PaymentId = PaymentsTestData.Payment1,
+                RefundPaymentMethod = null,
+                ExternalTradingCode = "testcode",
+                Currency = "CNY",
+                RefundAmount = 1.5m,
+                DisplayReason = "DisplayReason",
+                CustomerRemark = "CustomerRemark",
+                StaffRemark = "StaffRemark",
+                CompletedTime = now,
+                CanceledTime = null,
+                RefundItems = new List<RefundItemEto> { refundItem }
+            }));
+
+            var refundDto = await _refundAppService.GetAsync(PaymentsTestData.Refund1);
+            
+            refundDto.PaymentId.ShouldBe(PaymentsTestData.Payment1);
+            refundDto.ExternalTradingCode.ShouldBe("testcode");
+            refundDto.Currency.ShouldBe("CNY");
+            refundDto.RefundAmount.ShouldBe(1.5m);
+            refundDto.DisplayReason.ShouldBe("DisplayReason");
+            refundDto.CustomerRemark.ShouldBe("CustomerRemark");
+            refundDto.StaffRemark.ShouldBe("StaffRemark");
+            refundDto.CompletedTime.ShouldBe(now);
+            refundDto.CanceledTime.ShouldBeNull();
+            refundDto.RefundItems.Count.ShouldBe(1);
+
+            var refundItemDto = refundDto.RefundItems.First();
+            refundItemDto.Id.ShouldBe(PaymentsTestData.RefundItem1);
+            refundItemDto.PaymentItemId.ShouldBe(PaymentsTestData.PaymentItem1);
+            refundItemDto.RefundAmount.ShouldBe(1.5m);
+            refundItemDto.CustomerRemark.ShouldBe("CustomerRemark1");
+            refundItemDto.StaffRemark.ShouldBe("StaffRemark1");
+            // Extra properties
+            refundItemDto.StoreId.ShouldBe(PaymentsTestData.Store1);
+            refundItemDto.OrderId.ShouldBe(PaymentsTestData.Order1);
+            refundItemDto.OrderLines.Count.ShouldBe(1);
+            var orderLineDto = refundItemDto.OrderLines.First();
+            orderLineDto.OrderLineId.ShouldBe(PaymentsTestData.OrderLine1);
+            orderLineDto.RefundedQuantity.ShouldBe(2);
+            orderLineDto.RefundAmount.ShouldBe(1m);
+            refundItemDto.OrderExtraFees.Count.ShouldBe(1);
+            var orderExtraFee = refundItemDto.OrderExtraFees.First();
+            orderExtraFee.Name.ShouldBe("Name");
+            orderExtraFee.Key.ShouldBe("Key");
+            orderExtraFee.RefundAmount.ShouldBe(0.5m);
+        }
     }
 }

modules/EasyAbp.EShop.Payments/test/EasyAbp.EShop.Payments.TestBase/PaymentsTestData.cs

@@ -17,5 +17,9 @@ namespace EasyAbp.EShop.Payments
         public static Guid Payment2 { get; } = Guid.NewGuid();
         
         public static Guid PaymentItem1 { get; } = Guid.NewGuid();
+        
+        public static Guid Refund1 { get; } = Guid.NewGuid();
+        
+        public static Guid RefundItem1 { get; } = Guid.NewGuid();
     }
 }

plugins/Coupons/src/EasyAbp.EShop.Orders.Plugins.Coupons/EasyAbp/EShop/Orders/Plugins/Coupons/OrderDiscount/CouponOrderDiscountProvider.cs

@@ -35,15 +35,15 @@ namespace EasyAbp.EShop.Orders.Plugins.Coupons.OrderDiscount
         
         public virtual async Task<Order> DiscountAsync(Order order, Dictionary<Guid, ProductDto> productDict)
         {
-            if (!Guid.TryParse(order.GetProperty<string>(CouponsConsts.OrderCouponIdPropertyName),
-                out var couponId))
+            var couponId = order.GetProperty<Guid?>(CouponsConsts.OrderCouponIdPropertyName);
+            if (couponId is null)
             {
                 return order;
             }
 
             var now = _clock.Now;
 
-            var coupon = await _couponLookupService.FindByIdAsync(couponId);
+            var coupon = await _couponLookupService.FindByIdAsync(couponId.Value);
 
             if (coupon == null || coupon.ExpirationTime.HasValue && coupon.ExpirationTime.Value < now)
             {

plugins/Coupons/src/EasyAbp.EShop.Plugins.Coupons.Domain/EasyAbp/EShop/Plugins/Coupons/Coupons/CouponOrderCanceledEventHandler.cs

@@ -20,13 +20,13 @@ namespace EasyAbp.EShop.Plugins.Coupons.Coupons
         [UnitOfWork(true)]
         public virtual async Task HandleEventAsync(OrderCanceledEto eventData)
         {
-            if (!Guid.TryParse(eventData.Order.GetProperty<string>(CouponsConsts.OrderCouponIdPropertyName),
-                out var couponId))
+            var couponId = eventData.Order.GetProperty<Guid?>(CouponsConsts.OrderCouponIdPropertyName);
+            if (couponId is null)
             {
                 return;
             }
 
-            var coupon = await _couponRepository.GetAsync(couponId);
+            var coupon = await _couponRepository.GetAsync(couponId.Value);
             
             coupon.SetOrderId(null);
             coupon.SetUsed(null, null, null);

plugins/Coupons/src/EasyAbp.EShop.Plugins.Coupons.Domain/EasyAbp/EShop/Plugins/Coupons/Coupons/CouponOrderCreatedEventHandler.cs

@@ -26,15 +26,15 @@ namespace EasyAbp.EShop.Plugins.Coupons.Coupons
         [UnitOfWork(true)]
         public virtual async Task HandleEventAsync(EntityCreatedEto<OrderEto> eventData)
         {
-            if (!Guid.TryParse(eventData.Entity.GetProperty<string>(CouponsConsts.OrderCouponIdPropertyName),
-                out var couponId))
+            var couponId = eventData.Entity.GetProperty<Guid?>(CouponsConsts.OrderCouponIdPropertyName);
+            if (couponId is null)
             {
                 return;
             }
             
             var discountAmount = eventData.Entity.GetProperty<decimal>(CouponsConsts.OrderCouponDiscountAmountPropertyName);
 
-            var coupon = await _couponRepository.GetAsync(couponId);
+            var coupon = await _couponRepository.GetAsync(couponId.Value);
 
             if (coupon.OrderId != eventData.Entity.Id)
             {