fix:加入CreateACOOLYElectricOrder报错日志

zhengyuxuan

2025-04-02 2b6e63ae8a4af6f612e431c57d2f2f08fb9b9135

 LifePayment/LifePayment.Application/LifePay/LifePayOrderService.cs

@@ -16,6 +16,7 @@
using Newtonsoft.Json;
using LifePayment.Domain.Common;
using Spire.Pdf.Exporting.XPS.Schema;
using Nest;

namespace LifePayment.Application.LifePay
{
@@ -23,6 +24,8 @@
    {
        private readonly IRepository<LifePayRechargeReceipts, Guid> _lifePayRechargeReceiptsRepository;
        private readonly IRepository<LifePayExpensesReceipts, Guid> _lifePayExpensesReceiptsRepository;
        private readonly IRepository<LifePayConsumption, Guid> _lifePayConsumption;
        private readonly IRepository<LifePayChannles, Guid> _lifePayChannlesRep;
        private readonly IRepository<LifePayChannlesRake, Guid> _lifePayChannlesRakeRepository;
        private readonly IRepository<LifePayOrder, Guid> _lifePayOrderRepository;
        private readonly IAliPayApi _aliPayApi;
@@ -31,20 +34,62 @@
        public LifePayOrderService(
                              IRepository<LifePayRechargeReceipts, Guid> lifePayRechargeReceiptsRepository,
                              IRepository<LifePayExpensesReceipts, Guid> lifePayExpensesReceiptsRepository,
                              IRepository<LifePayConsumption, Guid> lifePayConsumptionRepository,
                              IRepository<LifePayChannlesRake, Guid> lifePayChannlesRakeRepository,
                              IRepository<LifePayChannles, Guid> lifePayChannlesRep,
                              IRepository<LifePayOrder, Guid> lifePayOrderRepository,
                              IAliPayApi aliPayApi,
                              IWxPayApi wxPayApi)
        {
            _lifePayRechargeReceiptsRepository = lifePayRechargeReceiptsRepository;
            _lifePayExpensesReceiptsRepository = lifePayExpensesReceiptsRepository;
            _lifePayConsumption = lifePayConsumptionRepository;
            _lifePayChannlesRakeRepository = lifePayChannlesRakeRepository;
            _lifePayChannlesRep = lifePayChannlesRep;
            _lifePayOrderRepository = lifePayOrderRepository;
            _aliPayApi = aliPayApi;
            _wxPayApi = wxPayApi;
        }

        #region 查询

        /// <summary>
        /// 获取消费流水
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageOutput<LifePayConsumptionListOutput>> GetLifePayConsumptionPage(LifePayConsumptionPageInput input)
        {
            var channles = await _lifePayChannlesRep.Where(x => x.ChannlesName.Contains(input.KeyWord)).Select(x => x.ChannlesNum).ToListAsync();
            var list = await _lifePayConsumption.Where(x => x.IsDeleted == false)
                .WhereIf(input.KeyWord.IsNotNullOrEmpty(), x => x.OrderNo.Contains(input.KeyWord) || x.AcoolyOrderNo.Contains(input.KeyWord) || channles.Contains(x.ChannelId))
                .WhereIf(input.Flow.HasValue, x => x.Flow == input.Flow)
                .WhereIf(input.TimeBegin.HasValue, x => x.FinishTime >= input.TimeBegin)
                .WhereIf(input.TimeEnd.HasValue, x => x.FinishTime <= input.TimeEnd)
                .Select(x => new LifePayConsumptionListOutput()
                {
                    Id = x.Id,
                    OrderNo = x.OrderNo,
                    AcoolyOrderNo = x.AcoolyOrderNo,
                    Amount = x.Amount,
                    ACOOLYStatus = x.ACOOLYStatus,
                    FinishTime = x.FinishTime,
                    FrozenStatus = x.FrozenStatus,
                    Flow = x.Flow,
                    DeductionAmount = x.DeductionAmount,
                    FrozenAmount = x.FrozenAmount.Value
                })
                .GetPageResult(input.PageModel);

            var totalDeductionAmount = await _lifePayConsumption.Where(x => x.IsDeleted == false).SumAsync(x => x.DeductionAmount);
            var totalFrozenAmount = await _lifePayConsumption.Where(x => x.IsDeleted == false).SumAsync(x => x.FrozenAmount);
            LifePayConsumptionStatistics objectData = new LifePayConsumptionStatistics();
            objectData.TotalDeductionAmount = totalDeductionAmount;
            objectData.TotalFrozenAmount = totalFrozenAmount.Value;
            list.ObjectData = objectData;
            return list;
        }

        /// <summary>
        /// 获取充值流水
        /// </summary>
@@ -208,7 +253,6 @@
            }
        }


        /// <summary>
        /// 插入收支流水
        /// </summary>
@@ -266,6 +310,7 @@
                                data.OrderNo = input.OrderNo;
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                data.FinishTime = Convert.ToDateTime(query.SuccessTime);
                                data.Amount = Convert.ToDecimal(query.Amount.Total) / 100;
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
@@ -277,11 +322,53 @@
                                data.OrderNo = input.OutRefundNo;
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                data.FinishTime = Convert.ToDateTime(query.SuccessTime);
                                data.Amount = Convert.ToDecimal(query.Amount.Total) / 100;
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
                        break;
                    default: break;
                }
            }
        }

        /// <summary>
        /// 统计所有消费流水
        /// </summary>
        /// <returns></returns>
        public async Task GetAllLifePayConsumption()
        {
            var orderList = await _lifePayOrderRepository.Where(x => x.PayStatus == LifePayStatusEnum.已支付).ToListAsync();
            foreach (var item in orderList)
            {
                LifePayConsumption lifePayConsumption = new LifePayConsumption()
                {
                    OrderNo = item.OrderNo,
                    AcoolyOrderNo = item.ACOOLYOrderNo,
                    Amount = item.PlatformDeductionAmount.HasValue? item.PlatformDeductionAmount.Value : 0,
                    ChannelId = item.ChannelId,
                };
                if (item.ACOOLYStatus != null)
                {
                    switch (item.ACOOLYStatus)
                    {
                        case ACOOLYStatusEnum.充值中:
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值中, item, lifePayConsumption);
                            break;
                        case ACOOLYStatusEnum.充值成功:
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值中, item, lifePayConsumption);
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值成功, item, lifePayConsumption);
                            break;
                        case ACOOLYStatusEnum.已完成:
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值中, item, lifePayConsumption);
                            await CreatLifePayConsumption(ACOOLYStatusEnum.已完成, item, lifePayConsumption);
                            break;
                        case ACOOLYStatusEnum.充值失败:
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值中, item, lifePayConsumption);
                            await CreatLifePayConsumption(ACOOLYStatusEnum.充值失败, item, lifePayConsumption);
                            break;
                        default: break;
                    }
                }
            }
        }
@@ -386,6 +473,96 @@

            return list;
        }

        private async Task CreatLifePayConsumption(ACOOLYStatusEnum status, LifePayOrder order, LifePayConsumption lifePayConsumption)
        {
            LifePayConsumption repeat = new LifePayConsumption();
            switch (status)
            {
                case ACOOLYStatusEnum.充值中:
                    lifePayConsumption.FinishTime = order.CreationTime;
                    lifePayConsumption.ACOOLYStatus = ACOOLYStatusEnum.充值中;
                    lifePayConsumption.FrozenStatus = ConsumptionFrozenStatusEnum.Frozen;
                    lifePayConsumption.Flow = ConsumptionFlowEnum.Unchanged;
                    lifePayConsumption.DeductionAmount = 0;
                    lifePayConsumption.FrozenAmount = lifePayConsumption.Amount;

                    repeat = await _lifePayConsumption.Where(x => x.OrderNo == lifePayConsumption.OrderNo
                    && x.ACOOLYStatus == lifePayConsumption.ACOOLYStatus && x.Flow == lifePayConsumption.Flow).FirstOrDefaultAsync();
                    if (repeat == null)
                    {
                        await _lifePayConsumption.InsertAsync(lifePayConsumption);
                    }

                    break;
                case ACOOLYStatusEnum.已完成:
                    lifePayConsumption.FinishTime = order.FinishTime.Value;
                    lifePayConsumption.ACOOLYStatus = ACOOLYStatusEnum.已完成;
                    lifePayConsumption.FrozenStatus = ConsumptionFrozenStatusEnum.Thaw;
                    lifePayConsumption.Flow = ConsumptionFlowEnum.Out;
                    lifePayConsumption.DeductionAmount = lifePayConsumption.Amount;
                    lifePayConsumption.FrozenAmount = 0;

                    repeat = await _lifePayConsumption.Where(x => x.OrderNo == lifePayConsumption.OrderNo
                    && x.ACOOLYStatus == lifePayConsumption.ACOOLYStatus && x.Flow == lifePayConsumption.Flow).FirstOrDefaultAsync();
                    if (repeat == null)
                    {
                        await _lifePayConsumption.InsertAsync(lifePayConsumption);
                    }

                    break;
                case ACOOLYStatusEnum.充值失败:
                    lifePayConsumption.FinishTime = order.CreationTime;
                    lifePayConsumption.ACOOLYStatus = ACOOLYStatusEnum.充值失败;
                    lifePayConsumption.FrozenStatus = ConsumptionFrozenStatusEnum.Frozen;
                    lifePayConsumption.Flow = ConsumptionFlowEnum.Unchanged;
                    lifePayConsumption.DeductionAmount = 0;
                    lifePayConsumption.FrozenAmount = lifePayConsumption.Amount;

                    repeat = await _lifePayConsumption.Where(x => x.OrderNo == lifePayConsumption.OrderNo
                    && x.ACOOLYStatus == lifePayConsumption.ACOOLYStatus && x.Flow == lifePayConsumption.Flow).FirstOrDefaultAsync();
                    if (repeat == null)
                    {
                        await _lifePayConsumption.InsertAsync(lifePayConsumption);
                    }

                    break;
                case ACOOLYStatusEnum.已退款:
                    lifePayConsumption.FinishTime = order.FinishTime.Value;
                    lifePayConsumption.ACOOLYStatus = ACOOLYStatusEnum.已退款;
                    lifePayConsumption.FrozenStatus = ConsumptionFrozenStatusEnum.Thaw;
                    lifePayConsumption.Flow = ConsumptionFlowEnum.Unchanged;
                    lifePayConsumption.DeductionAmount = 0;
                    lifePayConsumption.FrozenAmount = 0;

                    repeat = await _lifePayConsumption.Where(x => x.OrderNo == lifePayConsumption.OrderNo
                    && x.ACOOLYStatus == lifePayConsumption.ACOOLYStatus && x.Flow == lifePayConsumption.Flow).FirstOrDefaultAsync();
                    if (repeat == null)
                    {
                        await _lifePayConsumption.InsertAsync(lifePayConsumption);
                    }

                    break;

                //case ACOOLYStatusEnum.部分充值成功:
                //    lifePayConsumption.FinishTime = order.CreationTime;
                //    lifePayConsumption.ACOOLYStatus = ACOOLYStatusEnum.部分充值成功;
                //    lifePayConsumption.FrozenStatus = ConsumptionFrozenStatusEnum.Thaw;
                //    lifePayConsumption.Flow = ConsumptionFlowEnum.Unchanged;
                //    lifePayConsumption.DeductionAmount = 0;
                //    lifePayConsumption.FrozenAmount = lifePayConsumption.Amount;

                //    repeat = await _lifePayConsumption.Where(x => x.OrderNo == lifePayConsumption.OrderNo
                //    && x.ACOOLYStatus == lifePayConsumption.ACOOLYStatus && x.Flow == lifePayConsumption.Flow).FirstOrDefaultAsync();
                //    if (repeat == null)
                //    {
                //        await _lifePayConsumption.InsertAsync(lifePayConsumption);
                //    }

                //    break;
                default: break;
            }
        }
        #endregion

    }