public virtual async Task HandleEventAsync(WeChatPayRefundEto eventData)
{
// Todo: Handle errors and rollback
using (_currentTenant.Change(eventData.TenantId))
{
var payment = await _paymentRepository.GetAsync(eventData.PaymentId);
var paymentRecord = await _paymentRecordRepository.GetByPaymentId(eventData.PaymentId);
var refundRecordId = _guidGenerator.Create();
var dict = await RequestWeChatPayRefundAsync(payment, paymentRecord, eventData, refundRecordId.ToString());
var externalTradingCode = dict.GetOrDefault("refund_id");
eventData.Refund.SetExternalTradingCode(externalTradingCode);
await _refundRepository.UpdateAsync(eventData.Refund, true);
if (dict.GetOrDefault("result_code") != "SUCCESS")
{
await _paymentManager.RollbackRefundAsync(payment, eventData.Refund);
}
}
}
public virtual async Task CompleteRefundAsync(Payment payment, Refund refund)
{
using var uow = _unitOfWorkManager.Begin(isTransactional: true);
payment.CompleteRefund();
await _paymentRepository.UpdateAsync(payment, true);
refund.CompleteRefund(_clock.Now);
await _refundRepository.UpdateAsync(refund, true);
var paymentEto = _objectMapper.Map <Payment, PaymentEto>(payment);
var refundEto = _objectMapper.Map <Refund, RefundEto>(refund);
uow.OnCompleted(async() =>
await _distributedEventBus.PublishAsync(new PaymentRefundCompletedEto(paymentEto, refundEto)));
await uow.CompleteAsync();
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <RefundEto> eventData)
{
using var uow = _unitOfWorkManager.Begin(isTransactional: true);
using var changeTenant = _currentTenant.Change(eventData.Entity.TenantId);
var refund = await _refundRepository.FindAsync(eventData.Entity.Id);
if (refund == null)
{
return;
}
if (eventData.Entity.CompletedTime.HasValue && !refund.CompletedTime.HasValue)
{
uow.OnCompleted(async() => await _distributedEventBus.PublishAsync(new EShopRefundCompletedEto
{
Refund = _objectMapper.Map <Refund, EShopRefundEto>(refund)
}));
}
_objectMapper.Map(eventData.Entity, refund);
foreach (var etoItem in eventData.Entity.RefundItems)
{
var item = refund.RefundItems.FirstOrDefault(i => i.Id == etoItem.Id);
if (item == null)
{
item = _objectMapper.Map <RefundItemEto, RefundItem>(etoItem);
refund.RefundItems.Add(item);
}
else
{
_objectMapper.Map(etoItem, item);
}
FillRefundItemStoreId(item);
FillRefundItemOrderId(item);
}
var etoRefundItemIds = eventData.Entity.RefundItems.Select(i => i.Id).ToList();
refund.RefundItems.RemoveAll(i => !etoRefundItemIds.Contains(i.Id));
FillRefundItemOrderLines(refund);
await _refundRepository.UpdateAsync(refund, true);
await uow.CompleteAsync();
}
public virtual async Task CompleteRefundAsync(Payment payment, IEnumerable <Refund> refunds)
{
_unitOfWorkManager.Current.OnCompleted(async() =>
{
await _distributedEventBus.PublishAsync(new PaymentRefundRollbackEto
{
Payment = _objectMapper.Map <Payment, PaymentEto>(payment),
Refunds = _objectMapper.Map <IEnumerable <Refund>, IEnumerable <RefundEto> >(refunds)
});
});
payment.CompleteRefund();
await _paymentRepository.UpdateAsync(payment, true);
foreach (var refund in refunds)
{
refund.CompleteRefund(_clock.Now);
await _refundRepository.UpdateAsync(refund, true);
}
}
