/***********************************************************************
 *            Project: baifenBinfa
 *        ProjectName: 百分兵法管理系统                               
 *                Web: http://chuanyin.com                     
 *             Author:                                        
 *              Email:                               
 *         CreateTime: 202403/02   
 *        Description: 暂无
 ***********************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using CoreCms.Net.Caching.AutoMate.RedisCache;
using CoreCms.Net.Configuration;
using CoreCms.Net.IRepository;
using CoreCms.Net.IRepository.UnitOfWork;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.Entities.Expression;
using CoreCms.Net.Model.ViewModels.Basics;
using CoreCms.Net.Model.ViewModels.DTO;
using CoreCms.Net.Model.ViewModels.QueryMuch;
using CoreCms.Net.Model.ViewModels.UI;
using CoreCms.Net.Utility.Extensions;
using CoreCms.Net.Utility.Helper;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SqlSugar;


namespace CoreCms.Net.Services
{
    /// <summary>
    /// 退货单表 接口实现
    /// </summary>
    public class CoreCmsBillAftersalesServices : BaseServices<CoreCmsBillAftersales>, ICoreCmsBillAftersalesServices
    {
        private readonly ICoreCmsBillAftersalesRepository _dal;
        private readonly IUnitOfWork _unitOfWork;
        private readonly IServiceProvider _serviceProvider;
        private readonly ICoreCmsMessageCenterServices _messageCenterServices;
        private readonly ICoreCmsUserPointLogServices _userPointLogServices;
        private readonly IRedisOperationRepository _redisOperationRepository;


        public CoreCmsBillAftersalesServices(IUnitOfWork unitOfWork, ICoreCmsBillAftersalesRepository dal, IServiceProvider serviceProvider, ICoreCmsMessageCenterServices messageCenterServices, ICoreCmsUserPointLogServices userPointLogServices, IRedisOperationRepository redisOperationRepository)
        {
            this._dal = dal;
            base.BaseDal = dal;
            _unitOfWork = unitOfWork;
            _serviceProvider = serviceProvider;
            _messageCenterServices = messageCenterServices;
            _userPointLogServices = userPointLogServices;
            _redisOperationRepository = redisOperationRepository;
        }

        #region 根据订单号查询已经售后的内容======================

        /// <summary>
        /// 根据订单号查询已经售后的内容
        /// </summary>
        /// <param name="orderId">订单编号</param>
        /// <param name="aftersaleLevel">取售后单的时候，售后单的等级，0：待审核的和审核通过的售后单，1未审核的，2审核通过的</param>
        /// <returns></returns>
        public WebApiCallBack OrderToAftersales(string orderId, int aftersaleLevel = 0)
        {
            var jm = new WebApiCallBack();

            List<int> statusInts = new List<int>();
            switch (aftersaleLevel)
            {
                case 0:
                    statusInts.Add((int)GlobalEnumVars.BillAftersalesStatus.Success);
                    statusInts.Add((int)GlobalEnumVars.BillAftersalesStatus.WaitAudit);
                    break;
                case 1:
                    statusInts.Add((int)GlobalEnumVars.BillAftersalesStatus.WaitAudit);
                    break;
                case 2:
                    statusInts.Add((int)GlobalEnumVars.BillAftersalesStatus.Success);
                    break;
                default:
                    jm.msg = "aftersale_level值类型不对";
                    return jm;
            }
            //算已经退过款的金额，取已经完成的售后单的金额汇总
            var where = PredicateBuilder.True<CoreCmsBillAftersales>();
            where = where.And(p => p.orderId == orderId && statusInts.Contains(p.status));  //加上待审核状态，这样申请过售后的商品和金额不会再重复申请了
                                                                                            //已经退过款的金额
            var refundMoney = base.GetSum(where, p => p.refundAmount);

            //算退货商品明细
            var list = base.QueryMuch<CoreCmsBillAftersalesItem, CoreCmsBillAftersales, QMAfterSalesItems>(
                (child, parent) => new object[]
                {
                        JoinType.Inner, child.aftersalesId == parent.aftersalesId
                },
                (child, parent) => new QMAfterSalesItems
                {
                    orderItemsId = child.orderItemsId,
                    nums = child.nums,
                    status = parent.status,
                    type = parent.type
                }, (child, parent) => parent.orderId == orderId && statusInts.Contains(parent.status));

            var reshipGoods = new Dictionary<int, reshipGoods>();
            if (list != null && list.Count > 0)
            {
                foreach (var item in list)
                {
                    var reshipGoodsItem = new reshipGoods()
                    {
                        reshipNums = 0,
                        reshipedNums = 0
                    };
                    reshipGoodsItem.reshipNums += item.nums;
                    if (item.type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship)
                    {
                        reshipGoodsItem.reshipedNums += item.nums;
                    }
                    reshipGoods.Add(item.orderItemsId, reshipGoodsItem);
                }
            }

            var billAftersales = base.QueryListByClause(where);
            jm.data = new OrderToAfterSalesDto
            {
                refundMoney = refundMoney,
                reshipGoods = reshipGoods,
                billAftersales = billAftersales
            };
            jm.status = true;
            jm.msg = jm.status ? GlobalConstVars.GetDataSuccess : GlobalConstVars.GetDataFailure;

            return jm;
        }

        #endregion

        #region 统计用户的售后数量============================================

        /// <summary>
        /// 统计用户的售后数量
        /// </summary>
        /// <param name="whereExpression"></param>
        /// <param name="noLock"></param>
        /// <returns></returns>
        public async Task<int> GetUserAfterSalesNum(Expression<Func<CoreCmsBillAftersales, bool>> whereExpression, bool noLock = false)
        {
            var count = await base.GetCountAsync(whereExpression, noLock);
            return count;
        }
        #endregion

        #region 创建售后单
        /// <summary>
        /// 创建售后单
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="orderId">发起售后的订单</param>
        /// <param name="type">是否收到退货，1未收到退货，不会创建退货单，2收到退货，会创建退货单,只有未发货的商品才能选择未收到货，只有已发货的才能选择已收到货</param>
        /// <param name="items">如果是退款退货，退货的明细 以 [[order_item_id=>nums]]的二维数组形式传值</param>
        /// <param name="images"></param>
        /// <param name="reason">售后理由</param>
        /// <param name="refund">退款金额，只在退款退货的时候用，如果是退款，直接就是订单金额</param>
        /// <returns></returns>
        public async Task<WebApiCallBack> ToAdd(int userId, string orderId, int type, JArray items, string[] images, string reason, decimal refund)
        {
            var jm = new WebApiCallBack();

            //做个简单校验，防止乱传值
            if (type != (int)GlobalEnumVars.BillAftersalesIsReceive.Refund && type != (int)GlobalEnumVars.BillAftersalesIsReceive.Reship)
            {
                jm.msg = GlobalErrorCodeVars.Code10000;
                jm.code = 10000;
                return jm;
            }

            using var container = _serviceProvider.CreateScope();
            var orderServices = container.ServiceProvider.GetService<ICoreCmsOrderServices>();
            var orderItemServices = container.ServiceProvider.GetService<ICoreCmsOrderItemServices>();
            //var settingServices = container.ServiceProvider.GetService<ICoreCmsSettingServices>();
            var imagesServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesImagesServices>();
            var itemServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesItemServices>();
            var aftersalesServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesServices>();


            //判断是否存在还未处理的售后单据。
            var haveAS = await aftersalesServices.ExistsAsync(p => p.orderId == orderId && p.userId == userId && p.status == (int)GlobalEnumVars.BillAftersalesStatus.WaitAudit);
            if (haveAS)
            {
                jm.msg = "存在未处理的售后单";
                jm.status = false;
                return jm;
            }

            var orderInfo = await orderServices.QueryByClauseAsync(p => p.orderId == orderId && p.userId == userId);
            if (orderInfo == null)
            {
                jm.msg = GlobalErrorCodeVars.Code13101;
                jm.code = 13101;
                return jm;
            }
            orderInfo.items = await orderItemServices.QueryListByClauseAsync(p => p.orderId == orderInfo.orderId);

            orderServices.AfterSalesVal(orderInfo);

            if (orderInfo.addAftersalesStatus == false)
            {
                jm.msg = GlobalErrorCodeVars.Code13200;
                jm.code = 13200;
                return jm;
            }
            //生成售后单号
            var afterSalesId = CommonHelper.GetSerialNumberType((int)GlobalEnumVars.SerialNumberType.售后单编号);

            //校验订单是否可以进行此售后，并且校验订单价格是否合理
            var verifyResult = Verify(type, orderInfo, refund, items);
            if (verifyResult.status == false)
            {
                return verifyResult;
            }

            jm.otherData = new
            {
                orderInfo,
                items,
                verifyResult
            };

            //判断图片是否大于系统限定

            //var allConfigs = await settingServices.GetConfigDictionaries();
            if (images.Length > 5)
            {
                jm.msg = GlobalErrorCodeVars.Code10006;
                jm.code = 10006;
                return jm;
            }

            var aftersalesItemData = new List<CoreCmsBillAftersalesItem>();
            if (items != null && items.Any())
            {
                //如果是退货，判断退货明细，数量是否超出可退的数量
                var aftersalesItems = FormatAfterSalesItems(orderInfo, items, afterSalesId);
                if (!aftersalesItems.status)
                {
                    return aftersalesItems;
                }
                //保存售后明细
                if (aftersalesItems.data != null)
                {
                    aftersalesItemData = aftersalesItems.data as List<CoreCmsBillAftersalesItem>;
                }
                else
                {
                    jm.msg = "售后明细获取失败";
                    return jm;
                }
            }

            var billAftersales = new CoreCmsBillAftersales();
            billAftersales.aftersalesId = afterSalesId;
            billAftersales.orderId = orderId;
            billAftersales.userId = userId;
            billAftersales.type = type;
            billAftersales.refundAmount = refund;
            billAftersales.reason = reason;
            billAftersales.status = (int)GlobalEnumVars.BillAftersalesStatus.WaitAudit;
            billAftersales.createTime = DateTime.Now;
            //保存主表数据
            await _dal.InsertAsync(billAftersales);
            await itemServices.InsertAsync(aftersalesItemData);

            //保存图片
            if (images.Length > 0)
            {
                var imagesList = new List<CoreCmsBillAftersalesImages>();
                for (int i = 0; i < images.Length; i++)
                {
                    imagesList.Add(new CoreCmsBillAftersalesImages()
                    {
                        aftersalesId = afterSalesId,
                        imageUrl = images[i],
                        sortId = i
                    });
                }
                await imagesServices.InsertAsync(imagesList);
            }

            //消息模板推送给客户
            SmsHelper.SendMessage();

            orderInfo.billAftersalesId = afterSalesId;

            jm.status = true;
            jm.data = billAftersales;
            jm.msg = "售后申请成功！";
            return jm;
        }

        #endregion

        #region 校验是否可以进行售后
        /// <summary>
        /// 校验是否可以进行售后
        /// </summary>
        /// <param name="type"></param>
        /// <param name="orderInfo"></param>
        /// <param name="refund"></param>
        /// <param name="items"></param>
        /// <returns></returns>
        private WebApiCallBack Verify(int type, CoreCmsOrder orderInfo, decimal refund, JArray items)
        {
            var jm = new WebApiCallBack();
            //判断订单是否是可以售后
            //只有活动订单才能售后
            if (orderInfo.status != (int)GlobalEnumVars.OrderStatus.Normal)
            {
                jm.msg = GlobalErrorCodeVars.Code13200;
                jm.code = 13200;
                return jm;
            }
            //未付款订单和已退款订单不能售后
            if (orderInfo.payStatus == (int)GlobalEnumVars.OrderPayStatus.No || orderInfo.payStatus == (int)GlobalEnumVars.OrderPayStatus.Refunded)
            {
                jm.msg = GlobalErrorCodeVars.Code13203;
                jm.code = 13203;
                return jm;
            }
            //如果订单未发货，那么用户不能选择已收到货
            if (type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship && orderInfo.shipStatus == (int)GlobalEnumVars.OrderShipStatus.No)
            {
                jm.msg = GlobalErrorCodeVars.Code13227;
                jm.code = 13227;
                return jm;
            }
            //判断退款金额不能超
            if (refund + orderInfo.refunded > orderInfo.payedAmount)
            {
                jm.msg = GlobalErrorCodeVars.Code13206;
                jm.code = 13206;
                return jm;
            }
            //根据是否已收到货和未收到货来判断实际可以退的数量，不能超过最大数量，已收到货的和未收到货的不能一起退，在这里做判断
            return verifyNums(type, orderInfo, items);
        }
        #endregion

        #region 判断退货数量是否超标
        /// <summary>
        /// 判断退货数量是否超标
        /// </summary>
        /// <param name="type"></param>
        /// <param name="orderInfo"></param>
        /// <param name="items"></param>
        /// <returns></returns>
        private WebApiCallBack verifyNums(int type, CoreCmsOrder orderInfo, JArray items)
        {
            var jm = new WebApiCallBack();
            foreach (var item in items)
            {
                var id = ((JObject)item)["id"].ObjectToInt();
                var nums = ((JObject)item)["nums"].ObjectToInt();
                foreach (var orderItem in orderInfo.items)
                {
                    if (orderItem.id == id)
                    {
                        if (type == (int)GlobalEnumVars.BillAftersalesIsReceive.Refund)
                        {
                            //售后中未退换的数量（申请售后退还的，已经收到退还的，差额就是客户还需要退还的）
                            var reshipNum = orderItem.reshipNums - orderItem.reshipedNums;

                            //如果未发货，但申请售后大于0
                            if (orderItem.sendNums == 0 && nums > 0)
                            {
                                jm.msg = orderItem.name + orderItem.addon + "，未发货商品，退货数量只能为0个";
                                return jm;
                            }
                            //如果当前售后数量+未寄送的售后数量 > 已经发货数量
                            if (reshipNum + nums > orderItem.sendNums)
                            {
                                jm.msg = orderItem.name + orderItem.addon + "，售后申请超过数量，最多能退" + (orderItem.sendNums - reshipNum - nums) + "个";
                                return jm;
                            }
                        }
                        else
                        {
                            var n = orderItem.sendNums - orderItem.reshipedNums;
                            if (n < nums)
                            {
                                jm.msg = orderItem.name + orderItem.addon + "已发货商品，最多能退" + n + "个";
                                return jm;
                            }
                        }
                    }
                }
            }
            jm.status = true;
            return jm;
        }
        #endregion

        #region 根据退货的明细，生成售后单明细表的数据
        /// <summary>
        /// 根据退货的明细，生成售后单明细表的数据
        /// </summary>
        /// <param name="orderInfo">订单的详细数据</param>
        /// <param name="items">前台选择的退货商品信息</param>
        /// <param name="aftersalesId">将要保存的售后单的单号</param>
        /// <returns></returns>
        private WebApiCallBack FormatAfterSalesItems(CoreCmsOrder orderInfo, JArray items, string aftersalesId)
        {
            var jm = new WebApiCallBack();
            var data = new List<CoreCmsBillAftersalesItem>();
            foreach (var item in items)
            {
                var id = ((JObject)item)["id"].ObjectToInt();
                var nums = ((JObject)item)["nums"].ObjectToInt();

                if (nums < 0)
                {
                    continue;
                }

                foreach (var orderItem in orderInfo.items)
                {
                    if (orderItem.id == id)
                    {
                        //判断已经退过的加上本次退的，是否超过了购买的数量,具体取nums（购买数量）还是取sendnums(已发货数量),以后再说吧。要取购买数量，因为未发货的，也可以退的
                        if (nums + orderItem.reshipNums > orderItem.nums)
                        {
                            jm.msg = GlobalErrorCodeVars.Code13201;
                            jm.code = 13201;
                            return jm;
                        }
                        var billAftersalesItem = new CoreCmsBillAftersalesItem
                        {
                            aftersalesId = aftersalesId,
                            orderItemsId = orderItem.id,
                            goodsId = orderItem.goodsId,
                            productId = orderItem.productId,
                            sn = orderItem.sn,
                            bn = orderItem.bn,
                            name = orderItem.name,
                            imageUrl = orderItem.imageUrl,
                            nums = nums,
                            addon = orderItem.addon,
                            createTime = DateTime.Now
                        };
                        data.Add(billAftersalesItem);
                    }
                }
            }
            //判断生成的总记录条数，是否和前端传过来的记录条数对应上，如果没有对应上，就说明退货明细不正确
            if (data.Count != items.Count)
            {
                jm.msg = GlobalErrorCodeVars.Code13202;
                jm.data = jm.code = 13202;
                return jm;
            }
            jm.status = true;
            jm.data = data;
            return jm;
        }

        #endregion

        #region 带子集数据分页

        /// <summary>
        ///     根据条件查询分页数据
        /// </summary>
        /// <param name="predicate">判断集合</param>
        /// <param name="orderByType">排序方式</param>
        /// <param name="pageIndex">当前页面索引</param>
        /// <param name="pageSize">分布大小</param>
        /// <param name="orderByExpression"></param>
        /// <returns></returns>
        public async Task<IPageList<CoreCmsBillAftersales>> QueryPageAsync(Expression<Func<CoreCmsBillAftersales, bool>> predicate,
            Expression<Func<CoreCmsBillAftersales, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
            int pageSize = 20)
        {
            return await _dal.QueryPageAsync(predicate, orderByExpression, orderByType, pageIndex, pageSize);
        }

        #endregion

        #region 获取单个数据

        /// <summary>
        /// 获取单个数据
        /// </summary>
        /// <param name="aftersalesId"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<CoreCmsBillAftersales> GetInfo(string aftersalesId, int userId)
        {
            return await _dal.GetInfo(aftersalesId, userId);
        }
        #endregion

        #region Audit平台审核通过或者审核不通过

        /// <summary>
        /// 平台审核通过或者审核不通过
        /// 如果审核通过了，是退款单的话，自动生成退款单，并做订单完成状态，如果是退货的话，自动生成退款单和退货单，如果
        /// </summary>
        /// <param name="aftersalesId"></param>
        /// <param name="status"></param>
        /// <param name="type"></param>
        /// <param name="refund"></param>
        /// <param name="mark"></param>
        /// <param name="items"></param>
        /// <returns></returns>
        public async Task<WebApiCallBack> Audit(string aftersalesId, int status, int type, decimal refund, string mark,
            JArray items)
        {
            var jm = new WebApiCallBack();

            var res = await PreAudit(aftersalesId);
            if (!res.status)
            {
                return jm;
            }

            var info = res.data as CoreCmsBillAftersales;
            var orderInfo = info.order;

            //校验订单是否可以进行此售后，并且校验订单价格是否合理
            var verifyData = Verify(info.type, orderInfo, refund, items);
            if (!verifyData.status && status == (int)GlobalEnumVars.BillAftersalesStatus.Success)
            {
                return verifyData;
            }


            //如果订单未发货，那么用户不能选择已收到货
            if (type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship &&
                orderInfo.shipStatus == (int)GlobalEnumVars.OrderShipStatus.No)
            {
                jm.msg = GlobalErrorCodeVars.Code13227;
                jm.code = 13227;
                return jm;
            }

            //如果是退货单，必须选择退货明细
            if (info.type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship && items.Count <= 0)
            {
                jm.msg = GlobalErrorCodeVars.Code13205;
                jm.code = 13205;
                return jm;
            }

            //如果是退货，判断退货明细，数量是否超出可退的数量
            var billAftersalesItems = new List<CoreCmsBillAftersalesItem>();
            if (items.Count > 0)
            {
                var aftersalesItems = FormatAfterSalesItems(orderInfo, items, aftersalesId);
                if (!aftersalesItems.status)
                {
                    return aftersalesItems;
                }

                billAftersalesItems = aftersalesItems.data as List<CoreCmsBillAftersalesItem>;
            }

            //判断退款金额不能超了
            if (refund + orderInfo.refunded > orderInfo.payedAmount)
            {
                jm.msg = GlobalErrorCodeVars.Code13206;
                jm.code = 13206;
                return jm;
            }

            using (var container = _serviceProvider.CreateScope())
            {
                var itemServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesItemServices>();
                var orderServices = container.ServiceProvider.GetService<ICoreCmsOrderServices>();
                var refundServices = container.ServiceProvider.GetService<ICoreCmsBillRefundServices>();
                var reshipServices = container.ServiceProvider.GetService<ICoreCmsBillReshipServices>();
                var goodsServices = container.ServiceProvider.GetService<ICoreCmsGoodsServices>();
                var couponServices = container.ServiceProvider.GetService<ICoreCmsCouponServices>();
                //更新售后单
                await _dal.UpdateAsync(p => new CoreCmsBillAftersales() { status = status, mark = mark, refundAmount = refund, type = type },
                    p => p.aftersalesId == aftersalesId && p.status == (int)GlobalEnumVars.BillAftersalesStatus.WaitAudit);

                //更新售后单明细表，先删除，然后全新插入
                await itemServices.DeleteAsync(p => p.aftersalesId == aftersalesId);
                if (billAftersalesItems != null && billAftersalesItems.Any())
                {
                    await itemServices.InsertAsync(billAftersalesItems);
                }

                //审核通过的话，有退款的，生成退款单，根据最新的items生成退货单,并做订单的状态更改
                if (status == (int)GlobalEnumVars.BillAftersalesStatus.Success)
                {
                    //如果有退款，生成退款单
                    if (refund > 0)
                    {
                        var refundRes = await refundServices.ToAdd(info.userId, info.orderId, orderInfo.orderType, refund, info.aftersalesId);
                        if (!refundRes.status)
                        {
                            return refundRes;
                        }
                    }

                    //如果已经发货了，要退货，生成退货单，让用户吧商品邮回来。
                    if (info.type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship && billAftersalesItems != null && billAftersalesItems.Any())
                    {
                        var reshipRes = await reshipServices.ToAdd(info.userId, info.orderId, info.aftersalesId,
                            billAftersalesItems);
                        if (!reshipRes.status)
                        {
                            return reshipRes;
                        }
                    }
                    //更新订单状态

                    //如果是退款，退完了就变成已退款并且订单类型变成已完成，如果未退完，就是部分退款
                    if (refund > 0)
                    {
                        if (refund + orderInfo.refunded == orderInfo.payedAmount)
                        {
                            orderInfo.payStatus = (int)GlobalEnumVars.OrderPayStatus.Refunded;
                            orderInfo.status = (int)GlobalEnumVars.OrderStatus.Complete;

                            //返还积分（此模式会导致多次售后刷积分情况）
                            //if (orderInfo.point > 0)
                            //{
                            //    await _userPointLogServices.SetPoint(orderInfo.userId, orderInfo.point, (int)GlobalEnumVars.UserPointSourceTypes.PointRefundReturn, "售后退款：" + orderInfo.orderId + "返还积分");
                            //}
                            //返还优惠券
                            if (!string.IsNullOrEmpty(orderInfo.coupon))
                            {
                                await couponServices.CancelReturnCoupon(orderInfo.coupon);
                            }
                        }
                        else
                        {
                            orderInfo.payStatus = (int)GlobalEnumVars.OrderPayStatus.PartialNo;
                        }
                    }

                    //如果是0元购，积分单品兑换模式，也应该将订单类型变成已完成。
                    if (refund == 0 && orderInfo.point > 0 && orderInfo.pointMoney == orderInfo.goodsAmount)
                    {
                        orderInfo.status = (int)GlobalEnumVars.OrderStatus.Complete;
                    }

                    //判断货物发完没，如果货已发完了，订单发货就变成已发货,为了判断在有退款的情况下，当
                    var allDeliveryed = true;     //商品该发货状态，默认发货了,为了判断部分发货的情况下，的订单发货状态
                    var noDeliveryed = true;      //是否都没发货,默认都没发货
                    var allSened = true;          //商品退货状态（所有退货，包含已发的退货和未发的退货），默认都退货了,为了判断都退了的话，订单状态变成已完成

                    foreach (var item in orderInfo.items)
                    {
                        if (item.id > 0)
                        {
                            foreach (var jToken in items)
                            {
                                var tt = (JObject)jToken;
                                if (tt["id"].ToString() == item.id.ToString())
                                {
                                    item.reshipNums += tt["nums"].ObjectToInt(0);
                                    //判断 商品id相等，才能判断是否已发货，才能赋值给 reshipedNums 已发货的退货商品
                                    if (type == (int)GlobalEnumVars.BillAftersalesIsReceive.Reship)
                                    {
                                        item.reshipedNums += tt["nums"].ObjectToInt(0);
                                    }
                                }
                            }
                        }
                        //有任何商品发货，都不是未发货状态
                        if (noDeliveryed && item.sendNums > 0)
                        {
                            noDeliveryed = false;
                        }

                        if (allDeliveryed && (item.nums - item.sendNums - (item.reshipNums - item.reshipedNums) > 0))
                        {
                            //说明该发货的商品没发完
                            allDeliveryed = false;
                        }

                        if (allSened && (item.reshipNums < item.nums))
                        {
                            //说明未退完商品
                            allSened = false;
                        }
                    }

                    if (allDeliveryed && !noDeliveryed)
                    {
                        orderInfo.shipStatus = (int)GlobalEnumVars.OrderShipStatus.Yes;
                    }

                    if (allSened)
                    {
                        orderInfo.status = (int)GlobalEnumVars.OrderStatus.Complete;
                    }

                    //未发货的商品库存调整,如果订单未发货或者部分发货，并且用户未收到商品的情况下，需要解冻冻结库存
                    if ((orderInfo.shipStatus == (int)GlobalEnumVars.OrderShipStatus.No ||
                         orderInfo.shipStatus == (int)GlobalEnumVars.OrderShipStatus.PartialYes) &&
                        type == (int)GlobalEnumVars.BillAftersalesIsReceive.Refund &&
                        (billAftersalesItems != null && billAftersalesItems.Count > 0))
                    {
                        //未发货商品解冻库存
                        foreach (var item in billAftersalesItems)
                        {
                            goodsServices.ChangeStock(item.productId, GlobalEnumVars.OrderChangeStockType.refund.ToString(), item.nums);
                        }
                    }

                    //如果订单是已完成，但是订单的未发货商品还有的话，需要解冻库存
                    if (orderInfo.status == (int)GlobalEnumVars.OrderStatus.Complete)
                    {
                        foreach (var item in orderInfo.items)
                        {
                            var nums = item.nums - item.sendNums - (item.reshipNums - item.reshipedNums);//还未发货的数量
                            if (nums > 0)
                            {
                                goodsServices.ChangeStock(item.productId, GlobalEnumVars.OrderChangeStockType.refund.ToString(), nums);
                            }
                        }
                    }
                    //更新状态
                    await orderServices.UpdateAsync(
                        p => new CoreCmsOrder() { status = orderInfo.status, payStatus = orderInfo.payStatus },
                        p => p.orderId == orderInfo.orderId && p.status == (int)GlobalEnumVars.OrderStatus.Normal);
                }

                //售后单审核过后的事件处理
                if (status == (int)GlobalEnumVars.BillAftersalesStatus.Success)
                {
                    //售后审核通过后处理
                    await _redisOperationRepository.ListLeftPushAsync(RedisMessageQueueKey.AfterSalesReview, aftersalesId);
                    //售后审核通过后积分退还机制
                    await _redisOperationRepository.ListLeftPushAsync(RedisMessageQueueKey.AfterSalesReviewForPoint, aftersalesId);
                }

            }

            orderInfo.addAftersalesStatus = true;
            orderInfo.billAftersalesId = aftersalesId;
            orderInfo.mark = mark;

            //发送售后审核消息
            await _messageCenterServices.SendMessage(info.userId, GlobalEnumVars.PlatformMessageTypes.AfterSalesPass.ToString(), JObject.FromObject(orderInfo));

            jm.status = true;

            return jm;
        }

        #endregion

        #region 后端进行审核的时候，前置操作，1取出页面的数据，2在提交过来的表单的时候，进行

        /// <summary>
        /// 后端进行审核的时候，前置操作，1取出页面的数据，2在提交过来的表单的时候，进行校验
        /// </summary>
        /// <param name="aftersalesId"></param>
        /// <returns></return>
        public async Task<WebApiCallBack> PreAudit(string aftersalesId)
        {
            var jm = new WebApiCallBack();

            using var container = _serviceProvider.CreateScope();

            var userServices = container.ServiceProvider.GetService<ICoreCmsUserServices>();
            var imagesServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesImagesServices>();
            var itemServices = container.ServiceProvider.GetService<ICoreCmsBillAftersalesItemServices>();
            var orderServices = container.ServiceProvider.GetService<ICoreCmsOrderServices>();

            var model = await _dal.QueryByIdAsync(aftersalesId);

            var userModel = await userServices.QueryByClauseAsync(p => p.id == model.userId);
            model.userNickName = userModel != null ? userModel.nickName : "";
            model.statusName = EnumHelper.GetEnumDescriptionByValue<GlobalEnumVars.BillAftersalesStatus>(model.status);
            model.images = await imagesServices.QueryListByClauseAsync(p => p.aftersalesId == model.aftersalesId);
            model.items = await itemServices.QueryListByClauseAsync(p => p.aftersalesId == model.aftersalesId);

            //获取订单信息
            var orderResult = await orderServices.GetOrderInfoByOrderId(model.orderId, model.userId, 2);

            if (orderResult.status)
            {
                model.order = orderResult.data as CoreCmsOrder;

                //订单上的退款金额和数量只包含已经售后的，这里要把当次售后单的商品信息保存到订单
                foreach (var orderItem in model.order.items)
                {
                    orderItem.promotionList = string.Empty;
                    orderItem.atPresentReshipNums = 0;
                    foreach (var it in model.items)
                    {
                        if (orderItem.id == it.orderItemsId)
                        {
                            orderItem.atPresentReshipNums = it.nums;
                        }
                    }
                }
            }
            jm.status = true;
            jm.data = model;


            return jm;
        }
        #endregion

    }
}