using DevComponents.DotNetBar;
using DevComponents.DotNetBar.Controls;
using DevComponents.DotNetBar.SuperGrid;
using POS.Language.Language;
using POSV.Card;
using POSV.Component;
using POSV.Dianping;
using POSV.Entity;
using POSV.Helper;
using POSV.HttpApi;
using POSV.MessageEvent;
using POSV.PayApi;
using POSV.Payment.AllinPay.Models.ResponseModels;
using POSV.Payment.Saobei;
using POSV.Payment.Saobei.Parameter;
using POSV.Printer;
using POSV.Proxy.MIS;
using POSV.Proxy.ThirdPartyPayMent;
using POSV.ServiceCenter;
using POSV.Shift;
using POSV.ShoppingCart;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace POSV.Report
{
    public partial class SaleDetail : BusinessForm
    {
        public int orderType = -1;
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        [DllImport(@"landiccbmispos\MisPos.dll", EntryPoint = "BankTrans")]
        public static extern Int32 BankTrans(byte[] ptrIn, byte[] ptrOut);

        public SaleDetail()
        {
            InitializeComponent();
            this.controlBox1.Text = "营业单据查询";
            this.controlBox1.ShowApplicationVersion = false;
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            if (this.DesignMode) return;

            DefaultGridStyle.setDefaultGridStyle(this.salesListTable, false, false, GridLines.Horizontal, ColumnHeaderClickBehavior.SortAndReorder);


            DefaultGridStyle.setDefaultGridStyle(this.productListTable);

            DefaultGridStyle.setDefaultGridStyle(this.productMakeListTable);

            DefaultGridStyle.setDefaultGridStyle(this.payListTable);

            this.startPicker.Value = DateTime.Parse(Global.Instance.BusinessPlan.StartTimeSimple);
            this.endPicker.Value = DateTime.Parse(Global.Instance.BusinessPlan.EndTimeSimple);
            this.checkBoxX1.Checked = true;
            this.Focus();
            this.txtTradeNo.Focus();
            this.txtTradeNo.SelectAll();
            this.ActiveControl = this.txtTradeNo;
            //第一步获取订单列表
            List<BusinessTicket> detail = getBusTicketList(this.startPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"), this.endPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"));
            salesListTable.PrimaryGrid.DataSource = detail;

            #region subin 20231025 分账由实时改为交班时分账
            MsgEvent.RemoveListener(Constant.SPLITPAY_UPLOAD_PROGRESS, MessageEventNotify);
            MsgEvent.Receive(Constant.SPLITPAY_UPLOAD_PROGRESS, MessageEventNotify);
            #endregion
        }

        public List<BusinessTicket> getBusTicketList(string startTime, string endTime)
        {
            List<BusinessTicket> list = null;
            string busNo = StringUtils.GetString(this.txtTradeNo.Text);
            string orderNo = StringUtils.GetString(this.txtOrderNo.Text);

            //20230925 subin 增加桌号查询
            string tableNo = StringUtils.GetString(this.txtTableNo.Text);

            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    StringBuilder sqlBuld = new StringBuilder();
                    sqlBuld.Append(" select * ");
                    sqlBuld.Append(" from pos_order ");
                    sqlBuld.Append(" where finishDate >= '{0}' and finishDate <= '{1}'");
                    if (busNo != null && !"".Equals(busNo))
                    {
                        sqlBuld.Append(" and tradeNo like '%" + busNo + "%' ");
                    }
                    if (orderType >= 0)
                    {
                        sqlBuld.Append(" and orderType = " + orderType + " ");
                    }
                    if (!string.IsNullOrEmpty(orderNo))
                    {
                        sqlBuld.Append(" and orderNo = " + orderNo + " ");
                    }
                    //20230925 subin 增加桌号查询
                    if (!string.IsNullOrEmpty(tableNo))
                    {
                        sqlBuld.Append(" and tableNo = " + tableNo + " ");
                    }
                    sqlBuld.Append(" order by finishDate desc");

                    string sql = string.Format(sqlBuld.ToString(), startTime, endTime);

                    list = db.Query<BusinessTicket>(sql).ToList();
                }

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex);
            }
            if (list == null)
            {
                list = new List<BusinessTicket>();
            }
            foreach (BusinessTicket ticket in list)
            {
                if (!string.IsNullOrEmpty(ticket.OrgTradeNo))
                {
                    ticket.OrderStatus = 2;
                }
            }
            return list;
        }

        public List<OrderProduct> getOrderProductListByTradeNo(string tradeNo)
        {
            List<OrderProduct> list = null;
            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    StringBuilder sqlBuld = new StringBuilder();
                    sqlBuld.Append(" select * ");
                    sqlBuld.Append(" from pos_order_item ");
                    sqlBuld.Append(" where tradeNo = '{0}' ");
                    sqlBuld.Append(" order by orderNo ");

                    string sql = string.Format(sqlBuld.ToString(), tradeNo);
                    list = db.Query<OrderProduct>(sql).ToList();
                }

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex);
            }
            if (list == null)
            {
                list = new List<OrderProduct>();
            }
            return list;
        }

        public List<OrderPay> getOrderPayListByTradeNo(string tradeNo)
        {
            List<OrderPay> list = null;
            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    StringBuilder sqlBuld = new StringBuilder();
                    sqlBuld.Append(" select * ");
                    sqlBuld.Append(" from pos_order_pay ");
                    sqlBuld.Append(" where tradeNo = '{0}' ");
                    string sql = string.Format(sqlBuld.ToString(), tradeNo);
                    list = db.Query<OrderPay>(sql).ToList();
                }

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex);
            }
            if (list == null)
            {
                list = new List<OrderPay>();
            }
            return list;
        }

        public List<OrderMake> getOrderMakeListByItemId(string itemId)
        {
            List<OrderMake> list = null;
            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    StringBuilder sqlBuld = new StringBuilder();
                    sqlBuld.Append(" select * ");
                    sqlBuld.Append(" from pos_order_item_make ");
                    sqlBuld.Append(" where itemId = '{0}' ");
                    string sql = string.Format(sqlBuld.ToString(), itemId);
                    list = db.Query<OrderMake>(sql).ToList();
                }

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex);
            }
            if (list == null)
            {
                list = new List<OrderMake>();
            }
            return list;
        }

        public List<OrderInfo> getOrderInfoListByItemId(string orderId)
        {
            List<OrderInfo> list = null;
            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    StringBuilder sqlBuld = new StringBuilder();
                    sqlBuld.Append(" select * ");
                    sqlBuld.Append(" from pos_order_item_promotion ");
                    sqlBuld.Append(" where orderId = '{0}' ");
                    string sql = string.Format(sqlBuld.ToString(), orderId);
                    list = db.Query<OrderInfo>(sql).ToList();
                }

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex);
            }
            if (list == null)
            {
                list = new List<OrderInfo>();
            }
            return list;
        }

        private void OnControlBoxCloseClick(object sender, EventArgs e)
        {
            OnCloseTouchClick(sender, e);
        }


        private void OnCloseTouchClick(object sender, EventArgs e)
        {
            //先关闭父窗体
            if (this.Owner != null)
            {
                this.Owner.Close();
            }
            //再关闭当前窗体
            this.Close();
        }

        private void OnTicketRowActivated(object sender, GridRowActivatedEventArgs e)
        {

            GridPanel grid = e.GridPanel;
            if (e.NewActiveRow != null)
            {
                productListTable.PrimaryGrid.Rows.Clear();
                payListTable.PrimaryGrid.Rows.Clear();
                //先清除其他表数据
                GridRow row = e.NewActiveRow as GridRow;
                grid.SetSelected(e.NewActiveRow, false);
                grid.SetActiveRow(e.NewActiveRow);
                var tradeNo = row.Cells["busNo"].Value.ToString();
                List<OrderProduct> products = getOrderProductListByTradeNo(tradeNo);
                productListTable.PrimaryGrid.DataSource = products;
                List<OrderPay> pays = getOrderPayListByTradeNo(tradeNo);
                payListTable.PrimaryGrid.DataSource = pays;

            }
            else
            {
                productListTable.PrimaryGrid.Rows.Clear();
                payListTable.PrimaryGrid.Rows.Clear();
            }


        }

        private void OnOrderRowActivated(object sender, GridRowActivatedEventArgs e)
        {
            GridPanel grid = e.GridPanel;
            if (e.NewActiveRow != null)
            {
                productMakeListTable.PrimaryGrid.Rows.Clear();
                //先清除其他表数据
                GridRow row = e.NewActiveRow as GridRow;
                grid.SetSelected(e.NewActiveRow, false);
                grid.SetActiveRow(e.NewActiveRow);
                var itemId = row.Cells["itemId"].Value.ToString();
                List<OrderMake> makes = getOrderMakeListByItemId(itemId);
                productMakeListTable.PrimaryGrid.DataSource = makes;
            }
            else
            {
                productMakeListTable.PrimaryGrid.Rows.Clear();
            }
        }

        private void btn_exit_Click(object sender, EventArgs e)
        {
            OnCloseTouchClick(sender, e);
        }


        private void btn_time_Click(object sender, EventArgs e)
        {
            var obj = sender as ButtonX;
            var typeStr = obj.Tag as string;
            var type = (ReportQuickDate)Enum.Parse(typeof(ReportQuickDate), typeStr);
            var res = DateTimeUtils.CalculateBusinessPlanDate(type, this.startPicker.Value, this.endPicker.Value);
            this.startPicker.Value = res.Item1;
            this.endPicker.Value = res.Item2;
            List<BusinessTicket> detail = getBusTicketList(this.startPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"), this.endPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"));
            salesListTable.PrimaryGrid.DataSource = detail;
        }
        /// <summary>
        /// 查询按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_query_Click(object sender, EventArgs e)
        {
            QueryTicket();
        }

        public void QueryTicket()
        {
            //获取选择的订单
            List<BusinessTicket> detail = getBusTicketList(this.startPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"), this.endPicker.Value.ToString("yyyy-MM-dd HH:mm:ss"));
            salesListTable.PrimaryGrid.DataSource = detail;
        }

        private void RefundOrderCheck()
        {
            var panel = salesListTable.PrimaryGrid;
            if (panel.ActiveRow == null)
            {
                this.ShowToastNotify(this, LangProxy.ToLang("请选择要操作的单据"));
                return;
            }

            //练习模式不能进行退单操作
            if (Global.Instance.IsStudyMode())
            {
                this.ShowToastNotify(this, LangProxy.ToLang("练习模式不能退单！"));
                return;
            }

            //提示
            var row = panel.ActiveRow as GridRow;
            var tradeNo = row.Cells["busNo"].Value.ToString();

            bool allowBackPayHistory = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ALLOW_BACKPAY_HISTORY, true);
            //不允许退历史单据
            if (!allowBackPayHistory)
            {
                //判断是否是隔天的单据
                var finishDate = row.Cells["finishDate"].Value.ToString();
                string ticketDate = DateTime.Parse(finishDate).ToString("yyyy-MM-dd");
                if (!ticketDate.Equals(DateTime.Now.ToString("yyyy-MM-dd")))
                {
                    //不是同一天,查询设置
                    this.ShowToastNotify(this, LangProxy.ToLang("只能退款当日单据！"));
                    return;
                }
            }
            OrderObject orderObject = OrderUtils.getOrderObjectByTranNo(tradeNo);
            bool allowMemberBackTicket = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ALLOW_MEMBER_BACKTICKET, false);
            //不允许退有会员消费的单据
            if (allowMemberBackTicket)
            {
                bool isCoupon = false;
                if (orderObject.Promotions != null)
                {
                    var couponPromList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券).ToList();
                    if (couponPromList.Count > 0)
                    {
                        isCoupon = true;
                    }
                }
                if (orderObject.Items != null)
                {
                    foreach (OrderItem item in orderObject.Items)
                    {
                        if (item.Promotions != null)
                        {
                            var couponPromList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.电子兑换券).ToList();
                            if (couponPromList.Count > 0)
                            {
                                isCoupon = true;
                            }
                        }
                    }
                }
                if (isCoupon)
                {
                    DialogForm dialog = new DialogForm(LangProxy.ToLang("退款提醒"), LangProxy.ToLang("该订单使用了电子卡券,不允许退单!"), MessageBoxIcon.Warning, MessageBoxButtons.OK);
                    dialog.TopLevel = true;
                    dialog.ShowDialog(this);
                    return;
                }
            }
            if (orderObject.OrgTradeNo != null && !"".Equals(orderObject.OrgTradeNo) && orderObject.Items.Sum(x => x.Quantity - x.MiddleRefundQuantity) == decimal.Zero)
            {
                this.ShowToastNotify(this, LangProxy.ToLang("订单已完全退单"));
                return;
            }
            var causeForm = new RefundCauseSelectForm();
            causeForm.AcceptButtonClick += (o, args) =>
            {
                var partRefundCount = orderObject.Pays.FindAll(x => x.No == "01" || x.No == "02" || ((x.PayChannel == PayChannelEnum.乐刷支付 || x.PayChannel == PayChannelEnum.扫呗支付 || x.PayChannel == PayChannelEnum.通联支付) && (x.No == "04" || x.No == "05" || x.No == "07")) || x.No == "50").Count;
                if (partRefundCount != orderObject.Pays.Count)
                {
                    RefundOrder(tradeNo, args.Data.ToString(), null);
                }
                else
                {
                    var refundItemForm = new RefundItemForm();
                    refundItemForm.RefreshUi(orderObject);
                    refundItemForm.AcceptButtonClick += (o2, args2) =>
                    {
                        if (args2.Data is List<OrderItem> refundItems)
                        {
                            RefundOrder(tradeNo, args.Data.ToString(), refundItems);
                        }
                    };
                    refundItemForm.CancelButtonClick += (o2, args2) => { };

                    TransparentForm trans1 = new TransparentForm(this, refundItemForm);
                    trans1.Show(this);
                }
            };
            var trans = new TransparentForm(this, causeForm);
            trans.Show(this);
        }

        private void RefundOrder(string tradeNo, string refundCause, List<OrderItem> refundItems)
        {
            Task.Factory.StartNew(() =>
            {
                return DoRefund(tradeNo, refundCause, refundItems);
            }).ContinueWith(task =>
            {
                if (task.IsFaulted)
                {
                    LOGGER.Error(task.Exception.GetBaseException());
                }
                else
                {
                    if (!task.Result.Item1)
                    {
                        this.ShowToastNotify(this, LangProxy.ToLang("退款失败!"));
                        LOGGER.Info("退单失败！[{0}]", task.Result.Item2);
                        if (this.IsDisposed || !this.IsHandleCreated) return;
                        this.Invoke(new Action(() =>
                        {
                            DialogForm dialog = new DialogForm(LangProxy.ToLang("退款提醒"), LangProxy.ToLang("退款失败!") + task.Result.Item2, MessageBoxIcon.Warning, MessageBoxButtons.OK);
                            dialog.TopLevel = true;
                            dialog.ShowDialog(this);
                        }));
                    }
                    else
                    {
                        this.ShowToastNotify(this, "退单成功！");
                        LOGGER.Info("退单交易完成");
                        if (this.IsDisposed || !this.IsHandleCreated) return;
                        this.Invoke(new Action(() =>
                        {
                            DialogForm dialog = new DialogForm(LangProxy.ToLang("退款提醒"), LangProxy.ToLang("退款成功（金额原路退回）!"), MessageBoxIcon.Warning, MessageBoxButtons.OK);
                            dialog.TopLevel = true;
                            dialog.ShowDialog(this);
                            QueryTicket();
                        }));
                    }
                }
            });
        }

        /// <summary>
        /// 退款，全部按照支付分摊退款
        /// </summary>
        /// <param name="refundOrderObject"></param>
        /// <param name="orgOrderObject"></param>
        /// <returns></returns>
        private List<PayItem> CalculatePay(OrderObject refundOrderObject, OrderObject orgOrderObject)
        {
            var newPayList = new List<PayItem>();
            foreach (var item in refundOrderObject.Items)
            {
                if (item.RowState == OrderRowState.套餐明)
                {
                    continue;
                }

                //转正
                var tempTotalReceivableAmount = 0 - item.TotalReceivableAmount;
                //原订单明细项
                var oldOrderItem = orgOrderObject.Items.FirstOrDefault(x => x.Id == item.OrgItemId);
                if (oldOrderItem != null && oldOrderItem.ItemPayList != null && oldOrderItem.ItemPayList.Count > 0)
                {
                    //转正
                    bool allRe = false;
                    if (oldOrderItem.Quantity == oldOrderItem.MiddleRefundQuantity)
                    {
                        //本明细项全退，所有支付都退掉
                        allRe = true;
                    }
                    //明细项
                    foreach (var pay in oldOrderItem.ItemPayList)
                    {
                        //此明细还剩余金额
                        var balance = pay.ShareAmount - pay.RefundAmount;
                        //还有可分配的余额
                        if (balance == decimal.Zero)
                        {
                            //本分摊已完全使用
                            continue;
                        }
                        var currentSharedPay = tempTotalReceivableAmount;
                        if (balance < tempTotalReceivableAmount)
                        {
                            currentSharedPay = balance;
                        }
                        if (allRe)
                        {
                            //全退，余额全部推掉
                            currentSharedPay = balance;
                        }
                        tempTotalReceivableAmount -= currentSharedPay;

                        var existPay = newPayList.FirstOrDefault(x => x.OrgPayId == pay.PayId);
                        if (existPay == null)
                        {
                            existPay = new PayItem()
                            {
                                Id = IdWorkerUtils.Instance.NextId(),
                                OrgPayId = pay.PayId,
                                No = pay.No,
                                Name = pay.Name
                            };
                            newPayList.Add(existPay);
                        }

                        //每个明细都需要分配支付分摊
                        OrderItemPay itemPay = new OrderItemPay()
                        {
                            Id = IdWorkerUtils.Instance.NextId(),
                            TenantId = item.TenantId,
                            OrderId = item.OrderId,
                            TradeNo = item.TradeNo,
                            PayId = existPay.Id,
                            ItemId = item.Id,
                            No = pay.No,
                            Name = pay.Name,
                            ProductId = item.ProductId,
                            SpecId = item.SpecId,
                            ShareAmount = 0 - currentSharedPay,
                            ShareCouponLeastCost = pay.ShareCouponLeastCost,
                            RefundAmount = decimal.Zero
                        };
                        item.ItemPayList.Add(itemPay);

                        existPay.PaidAmount += (0 - currentSharedPay);
                        //原分摊记录退款金额

                        pay.RefundAmount += currentSharedPay;

                        if (!allRe && tempTotalReceivableAmount <= 0M)
                        {
                            //排除全退的情况，全退，需要处理抹零，抹零也要退掉
                            //该行明细分摊完成
                            break;
                        }
                    }
                }
            }
            return newPayList;
        }

        /// <summary>
        /// 退款，全部按照支付分摊退款
        /// </summary>
        /// <param name="refundOrderObject"></param>
        /// <param name="orgOrderObject"></param>
        /// <returns></returns>
        private List<PayItem> CalculateWxPay(OrderObject refundOrderObject, OrderObject orgOrderObject)
        {
            var newPayList = new List<PayItem>();

            var orgOrderPay = orgOrderObject.Pays[0];

            foreach (var item in refundOrderObject.Items)
            {
                if (item.RowState == OrderRowState.套餐明)
                {
                    continue;
                }

                //转正
                var tempTotalReceivableAmount = 0 - item.TotalReceivableAmount;
                //原订单明细项
                var oldOrderItem = orgOrderObject.Items.FirstOrDefault(x => x.Id == item.OrgItemId);
                if (oldOrderItem != null)
                {
                    //转正
                    bool allRe = false;
                    if (oldOrderItem.Quantity == oldOrderItem.MiddleRefundQuantity)
                    {
                        //本明细项全退，所有支付都退掉
                        allRe = true;
                    }

                    var tmpBalance = orgOrderPay.PaidAmount - orgOrderPay.RefundAmount;

                    if (tmpBalance == decimal.Zero)
                    {
                        //本分摊已完全使用
                        continue;
                    }
                    var currentSharedPay = tempTotalReceivableAmount;
                    if (tmpBalance < tempTotalReceivableAmount)
                    {
                        currentSharedPay = tmpBalance;
                    }
                    if (allRe)
                    {
                        //全退，余额全部推掉
                        currentSharedPay = tmpBalance;
                    }

                    tempTotalReceivableAmount -= currentSharedPay;


                }
            }
            return newPayList;
        }

        private Tuple<bool, string> DoRefund(string tradeNo, string refundCause, List<OrderItem> refundItems)
        {
            try
            {
                OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo(tradeNo);

                //交班订单不允许退款判断
                if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_SHIFTISALLOWREFUND, false))
                {
                    if (!_OrderObject.ShiftNo.Equals(Global.Instance.BusinessPlanLog.No))
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("系统已设置交班后的订单不允许退款！"));
                    }
                }

                if (_OrderObject != null)
                {
                    if (_OrderObject.OrgTradeNo != null && !"".Equals(_OrderObject.OrgTradeNo) && _OrderObject.Items.Sum(x => x.Quantity - x.MiddleRefundQuantity) == decimal.Zero)
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("订单已完全退单"));
                    }

                    #region subin 20230916 将原始的微信点餐退款条件去掉，将原微信点餐“同意退款"修改为门店销售订单退款。
                    //if (OrderType.微信点餐 == _OrderObject.OrderType || OrderType.百度外卖 == _OrderObject.OrderType || OrderType.饿了么 == _OrderObject.OrderType)
                    //{
                    //    return new Tuple<bool, string>(false, LangProxy.ToLang("只有 堂食、外带、餐桌 模式的单据的才能在此退单"));
                    //}
                    if (OrderType.百度外卖 == _OrderObject.OrderType || OrderType.饿了么 == _OrderObject.OrderType)
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("只有 堂食、外带、餐桌 模式的单据的才能在此退单"));
                    }
                    #endregion
                    if (OrderType.电话外卖 == _OrderObject.OrderType)
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("电话外卖订单请到外送汇总里面退单"));
                    }
                    if (OrderType.电话外卖 == _OrderObject.OrderType)
                    {
                        if (_OrderObject.Delivery != null && _OrderObject.Delivery.Status == 2)
                        {
                            return new Tuple<bool, string>(false, LangProxy.ToLang("电话外卖已交单，退款失败！"));
                        }
                    }
                    #region subin bak
                    ////生成新单
                    //OrderObject _BackOrderObject = ObjectUtils.Copy(_OrderObject);
                    //string finishDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    ////=========更新原单内容
                    ////录入原单号
                    //_BackOrderObject.Id = IdWorkerUtils.Instance.NextId();
                    ////操作员工号
                    //_BackOrderObject.WorkerNo = Global.Instance.Worker.No;
                    ////操作员名称
                    //_BackOrderObject.WorkerName = Global.Instance.Worker.Name;
                    //_BackOrderObject.SaleDate = finishDate;
                    ////班次名称
                    //_BackOrderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;
                    ////班次编号
                    //_BackOrderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;
                    ////订单标识为 新建状态
                    //_BackOrderObject.OrderStatus = OrderStatus.已退单;
                    ////订单创建时间
                    //_BackOrderObject.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    ////订单创建人
                    //_BackOrderObject.CreateUser = Global.Instance.Worker.Name;
                    //string[] day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
                    //string weeker = day[Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"))].ToString();
                    ////星期
                    //_BackOrderObject.Weeker = weeker;
                    ////天气
                    //_BackOrderObject.Weather = string.Empty;
                    //_BackOrderObject.ObjectId = ObjectId.GenerateNewStringId();
                    //var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                    //if (ticket.Item1)
                    //{
                    //    _BackOrderObject.TradeNo = ticket.Item3;
                    //}
                    //else
                    //{
                    //    return new Tuple<bool, string>(false, LangProxy.ToLang("生成票号失败，退款失败！"));
                    //}
                    //_BackOrderObject.FinishDate = finishDate;
                    //_BackOrderObject.Amount = 0 - _OrderObject.Amount;
                    //_BackOrderObject.DiscountAmount = 0 - _OrderObject.DiscountAmount;
                    //_BackOrderObject.ReceivableAmount = 0 - _OrderObject.ReceivableAmount;
                    //_BackOrderObject.PaidAmount = 0 - _OrderObject.PaidAmount;
                    //_BackOrderObject.ReceivedAmount = 0 - _OrderObject.ReceivedAmount;
                    //_BackOrderObject.MalingAmount = 0 - _OrderObject.MalingAmount;
                    //_BackOrderObject.ChangeAmount = 0 - _OrderObject.ChangeAmount;
                    //_BackOrderObject.InvoicedAmount = 0 - _OrderObject.InvoicedAmount;
                    //_BackOrderObject.SyncStatus = 0;
                    //_BackOrderObject.PrintStatus = 0;
                    //_BackOrderObject.AddPoint = 0 - _OrderObject.AddPoint;
                    //_BackOrderObject.UploadStatus = 0;
                    //_BackOrderObject.UploadMessage = "";
                    //_BackOrderObject.TicketId = "";
                    //_BackOrderObject.OrgTradeNo = _OrderObject.TradeNo;
                    //_BackOrderObject.RefundCause = refundCause;

                    ////电话外送
                    //if (OrderType.电话外卖 == _BackOrderObject.OrderType)
                    //{
                    //    _OrderObject.OrderStatus = OrderStatus.已完成;
                    //    _OrderObject.PaymentStatus = OrderPaymentStatus.已付款;
                    //    //电话外卖退单后原单重新上传
                    //    _OrderObject.SyncStatus = 0;
                    //    _OrderObject.UploadErrors = 0;
                    //    var _backDelivery = _BackOrderObject.Delivery;
                    //    if (_backDelivery != null)
                    //    {
                    //        _backDelivery.Id = IdWorkerUtils.Instance.NextId();
                    //        _backDelivery.OrderId = _BackOrderObject.Id;
                    //        _backDelivery.TradeNo = _BackOrderObject.TradeNo;
                    //        _backDelivery.ShiftNo = Global.Instance.BusinessPlanLog.No;
                    //        _backDelivery.ShiftName = Global.Instance.BusinessPlanLog.Name;
                    //        _backDelivery.Status = 2;

                    //        if (!string.IsNullOrEmpty(_backDelivery.SendDate))
                    //        {
                    //            _backDelivery.SendDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    //        }
                    //        _backDelivery.SettlementDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                    //    }
                    //}

                    ////整单优惠
                    //foreach (PromotionOrder promotion in _BackOrderObject.Promotions)
                    //{
                    //    promotion.Id = IdWorkerUtils.Instance.NextId();
                    //    promotion.OrderId = _BackOrderObject.Id;
                    //    promotion.TradeNo = _BackOrderObject.TradeNo;
                    //    promotion.Amount = 0 - promotion.Amount;
                    //    promotion.DiscountAmount = 0 - promotion.DiscountAmount;
                    //    promotion.ReceivableAmount = 0 - promotion.ReceivableAmount;
                    //    promotion.FinishDate = finishDate;
                    //}

                    //List<OrderItem> backOrderItems = new List<OrderItem>();
                    ////====== 更新明细内容
                    //foreach (OrderItem item in _BackOrderObject.Items)
                    //{
                    //    OrderItem refundItem = null;
                    //    //部分退商品明细(退的原单)
                    //    if (refundItems != null && refundItems.Count > 0)
                    //    {
                    //        if (!refundItems.Exists(x => x.Id == item.Id))
                    //        {
                    //            continue;
                    //        }
                    //        refundItem = refundItems.FirstOrDefault(x => x.Id == item.Id);
                    //    }

                    //    //有效数量
                    //    var _effectiveQuantity = item.Quantity - item.MiddleRefundQuantity;
                    //    if (_effectiveQuantity <= 0)
                    //    {
                    //        //排除不可退的商品
                    //        continue;
                    //    }

                    //    //退货数量为正数
                    //    var refundQuantity = refundItem != null ? refundItem.Quantity : item.Quantity;
                    //    var refundAmount = refundItem != null ? refundItem.Amount : item.Amount;
                    //    //部分退货情况下的占比，用于处理促销优惠
                    //    decimal rate = refundQuantity / item.Quantity;

                    //    item.OrgItemId = item.Id;
                    //    item.Id = IdWorkerUtils.Instance.NextId();
                    //    item.OrderId = _BackOrderObject.Id;
                    //    item.TradeNo = _BackOrderObject.TradeNo;
                    //    //单品优惠
                    //    foreach (PromotionItem promotion in item.Promotions)
                    //    {
                    //        promotion.Id = IdWorkerUtils.Instance.NextId();
                    //        promotion.OrderId = _BackOrderObject.Id;
                    //        promotion.ItemId = item.Id;
                    //        promotion.TradeNo = _BackOrderObject.TradeNo;

                    //        promotion.Amount = (0 - promotion.Amount) * rate;
                    //        promotion.DiscountAmount = (0 - promotion.DiscountAmount) * rate;
                    //        promotion.ReceivableAmount = (0 - promotion.ReceivableAmount) * rate;
                    //        promotion.FinishDate = finishDate;
                    //        promotion.RelationId = promotion.RelationId == "0" ? string.Empty : promotion.RelationId;
                    //    }
                    //    //做法信息
                    //    foreach (FlavorItem flavor in item.Flavors)
                    //    {
                    //        flavor.Id = IdWorkerUtils.Instance.NextId();
                    //        flavor.OrderId = _BackOrderObject.Id;
                    //        flavor.ItemId = item.Id;
                    //        flavor.TradeNo = _BackOrderObject.TradeNo;
                    //        flavor.isRefund = true;
                    //        flavor.OrderItemQuantity = refundQuantity;
                    //        flavor.RefundQuantity = refundQuantity;
                    //        flavor.Amount = flavor.Amount;
                    //        flavor.Quantity = flavor.Quantity;
                    //        flavor.DiscountAmount = 0 - flavor.DiscountAmount;
                    //        flavor.FinishDate = finishDate;
                    //        flavor.isBackTicket = true;
                    //    }

                    //    //清空支付方式分摊
                    //    item.ItemPayList = new List<OrderItemPay>();

                    //    item.MiddleRefundQuantity = refundQuantity;
                    //    item.RefundQuantity = refundQuantity;
                    //    item.Quantity = 0;
                    //    item.Amount = 0 - refundAmount;
                    //    item.FlavorAmount = 0 - item.FlavorAmount;
                    //    item.FlavorDiscountAmount = 0 - item.FlavorDiscountAmount;
                    //    item.FlavorReceivableAmount = 0 - item.FlavorReceivableAmount;
                    //    item.TotalAmonut = 0 - item.TotalAmonut;
                    //    item.SuitAddPrice = 0 - item.SuitAddPrice;
                    //    item.SuitAmount = 0 - item.SuitAmount;
                    //    item.SaleDate = finishDate;
                    //    item.ChudaQty = 0;
                    //    item.ChupinQty = 0;
                    //    item.ChuxianQty = 0;
                    //    item.KdsChupinQty = 0;
                    //    item.FinishDate = finishDate;

                    //    if (item.RowState == OrderRowState.套餐明)
                    //    {
                    //        var newItem = backOrderItems.FirstOrDefault(x => x.OrgItemId == item.ParentId);
                    //        if (newItem != null)
                    //        {
                    //            item.ParentId = newItem.Id;
                    //            item.Group = newItem.Id;
                    //        }
                    //    }
                    //    else
                    //    {
                    //        item.Group = item.Id;
                    //    }

                    //    //原单-更新退货数量
                    //    var oldItem = _OrderObject.Items.FirstOrDefault(x => x.Id == item.OrgItemId);
                    //    oldItem.MiddleRefundQuantity += refundQuantity;
                    //    if (oldItem.Flavors != null && oldItem.Flavors.Count > 0)
                    //    {
                    //        oldItem.Flavors.ForEach(x =>
                    //        {
                    //            x.RefundQuantity += x.BaseQuantity * refundQuantity;
                    //        });
                    //    }

                    //    //计算套餐主的做法金额
                    //    PromotionUtils.UpdateSuitMain(_BackOrderObject, item);

                    //    backOrderItems.Add(item);
                    //}

                    //_BackOrderObject.Items = backOrderItems;

                    ////退款，全部按照支付分摊退款
                    //var newPayList = CalculatePay(_BackOrderObject, _OrderObject);

                    //decimal diffAmount = 0 - _BackOrderObject.PaidAmount;

                    //#region subin 20230916 原本地订单退款中增加小程序退款，包括小程序单品退
                    ////支付方式遍历
                    //foreach (PayItem pay in _BackOrderObject.Pays)
                    //{
                    //    //分摊新流程，按照分摊的金额进行扣款
                    //    PayItem sharePay = null;
                    //    if (newPayList != null && newPayList.Count > 0)
                    //    {
                    //        sharePay = newPayList.FirstOrDefault(x => x.OrgPayId == pay.Id);
                    //        if (sharePay == null)
                    //        {
                    //            //存在分摊，但是当前支付方式不在本次应退范围（上面计算的商品分摊），跳过
                    //            continue;
                    //        }
                    //    }

                    //    var oldPay = _OrderObject.Pays.FirstOrDefault(x => x.Id == pay.Id);

                    //    if (sharePay != null)
                    //    {
                    //        //启用了分摊，按照分摊中的支付进行扣款
                    //        pay.Id = sharePay.Id;

                    //        pay.Amount = sharePay.PaidAmount;
                    //        //当前支付方式余额
                    //        var balanceAmount = pay.PaidAmount - pay.RefundAmount;
                    //        if (Math.Abs(balanceAmount) < Math.Abs(pay.Amount))
                    //        {
                    //            //本次扣款不足，余额扣掉即可
                    //            pay.Amount = 0 - balanceAmount;
                    //        }
                    //        //除去代金券的剩余金额，每次应该减去代金券分摊金额
                    //        diffAmount -= (0 - pay.Amount);
                    //    }
                    //    else
                    //    {
                    //        //沿用旧的逻辑，按顺序扣款
                    //        pay.Id = IdWorkerUtils.Instance.NextId();

                    //        //当前支付方式余额
                    //        var balanceAmount = pay.PaidAmount - pay.RefundAmount;

                    //        diffAmount -= balanceAmount;
                    //        if (diffAmount >= 0)
                    //        {
                    //            //当前支付方式的金额不足，全部付款
                    //            pay.Amount = (0 - balanceAmount);
                    //        }
                    //        else
                    //        {
                    //            //足够，将剩余金额扣掉即可
                    //            pay.Amount = (0 - (balanceAmount + diffAmount));
                    //        }
                    //    }

                    //    pay.PaidAmount = pay.Amount;
                    //    pay.RefundAmount = 0M;
                    //    pay.TradeNo = _BackOrderObject.TradeNo;
                    //    pay.PayNo = OrderUtils.Instance.GeneratePayNo();
                    //    pay.OrderId = _BackOrderObject.Id;
                    //    pay.ChangeAmount = 0 - pay.ChangeAmount;
                    //    pay.PayTime = finishDate;
                    //    pay.FinishDate = finishDate;
                    //    pay.OverAmount = 0 - pay.OverAmount;
                    //    pay.ShiftName = _BackOrderObject.ShiftName;
                    //    pay.ShiftNo = _BackOrderObject.ShiftNo;

                    //    //记录当前支付方式的已退款金额
                    //    oldPay.RefundAmount += pay.PaidAmount * -1;

                    //    var tempRefundAmount = pay.PaidAmount * -1; 
                    #endregion

                    //生成新单
                    OrderObject _BackOrderObject = ObjectUtils.Copy(_OrderObject);
                    string finishDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    //=========更新原单内容
                    //录入原单号
                    _BackOrderObject.Id = IdWorkerUtils.Instance.NextId();
                    //操作员工号
                    _BackOrderObject.WorkerNo = Global.Instance.Worker.No;
                    //操作员名称
                    _BackOrderObject.WorkerName = Global.Instance.Worker.Name;
                    _BackOrderObject.SaleDate = finishDate;
                    //班次名称
                    _BackOrderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;
                    //班次编号
                    _BackOrderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;
                    //订单标识为 新建状态
                    _BackOrderObject.OrderStatus = OrderStatus.已退单;
                    //订单创建时间
                    _BackOrderObject.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    //订单创建人
                    _BackOrderObject.CreateUser = Global.Instance.Worker.Name;
                    string[] day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
                    string weeker = day[Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"))].ToString();
                    //星期
                    _BackOrderObject.Weeker = weeker;
                    //天气
                    _BackOrderObject.Weather = string.Empty;
                    _BackOrderObject.ObjectId = ObjectId.GenerateNewStringId();
                    var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                    if (ticket.Item1)
                    {
                        _BackOrderObject.TradeNo = ticket.Item3;
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("生成票号失败，退款失败！"));
                    }
                    _BackOrderObject.FinishDate = finishDate;
                    _BackOrderObject.Amount = 0 - _OrderObject.Amount;
                    _BackOrderObject.DiscountAmount = 0 - _OrderObject.DiscountAmount;
                    _BackOrderObject.ReceivableAmount = 0 - _OrderObject.ReceivableAmount;
                    _BackOrderObject.PaidAmount = 0 - _OrderObject.PaidAmount;
                    _BackOrderObject.ReceivedAmount = 0 - _OrderObject.ReceivedAmount;
                    _BackOrderObject.MalingAmount = 0 - _OrderObject.MalingAmount;
                    _BackOrderObject.ChangeAmount = 0 - _OrderObject.ChangeAmount;
                    _BackOrderObject.InvoicedAmount = 0 - _OrderObject.InvoicedAmount;
                    _BackOrderObject.SyncStatus = 0;
                    _BackOrderObject.PrintStatus = 0;
                    _BackOrderObject.AddPoint = 0 - _OrderObject.AddPoint;
                    _BackOrderObject.UploadStatus = 0;
                    _BackOrderObject.UploadMessage = "";
                    _BackOrderObject.TicketId = "";
                    _BackOrderObject.OrgTradeNo = _OrderObject.TradeNo;
                    _BackOrderObject.RefundCause = refundCause;

                    //电话外送
                    if (OrderType.电话外卖 == _BackOrderObject.OrderType)
                    {
                        _OrderObject.OrderStatus = OrderStatus.已完成;
                        _OrderObject.PaymentStatus = OrderPaymentStatus.已付款;
                        //电话外卖退单后原单重新上传
                        _OrderObject.SyncStatus = 0;
                        _OrderObject.UploadErrors = 0;
                        var _backDelivery = _BackOrderObject.Delivery;
                        if (_backDelivery != null)
                        {
                            _backDelivery.Id = IdWorkerUtils.Instance.NextId();
                            _backDelivery.OrderId = _BackOrderObject.Id;
                            _backDelivery.TradeNo = _BackOrderObject.TradeNo;
                            _backDelivery.ShiftNo = Global.Instance.BusinessPlanLog.No;
                            _backDelivery.ShiftName = Global.Instance.BusinessPlanLog.Name;
                            _backDelivery.Status = 2;

                            if (!string.IsNullOrEmpty(_backDelivery.SendDate))
                            {
                                _backDelivery.SendDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            }
                            _backDelivery.SettlementDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                        }
                    }

                    //整单优惠
                    foreach (PromotionOrder promotion in _BackOrderObject.Promotions)
                    {
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        promotion.OrderId = _BackOrderObject.Id;
                        promotion.TradeNo = _BackOrderObject.TradeNo;
                        promotion.Amount = 0 - promotion.Amount;
                        promotion.DiscountAmount = 0 - promotion.DiscountAmount;
                        promotion.ReceivableAmount = 0 - promotion.ReceivableAmount;
                        promotion.FinishDate = finishDate;
                    }

                    List<OrderItem> backOrderItems = new List<OrderItem>();
                    //====== 更新明细内容
                    foreach (OrderItem item in _BackOrderObject.Items)
                    {
                        OrderItem refundItem = null;
                        //部分退商品明细(退的原单)
                        if (refundItems != null && refundItems.Count > 0)
                        {
                            if (!refundItems.Exists(x => x.Id == item.Id))
                            {
                                continue;
                            }
                            refundItem = refundItems.FirstOrDefault(x => x.Id == item.Id);
                        }

                        //有效数量
                        var _effectiveQuantity = item.Quantity - item.MiddleRefundQuantity;
                        if (_effectiveQuantity <= 0)
                        {
                            //排除不可退的商品
                            continue;
                        }

                        //退货数量为正数
                        var refundQuantity = refundItem != null ? refundItem.Quantity : item.Quantity;
                        var refundAmount = refundItem != null ? refundItem.Amount : item.Amount;
                        //部分退货情况下的占比，用于处理促销优惠
                        decimal rate = refundQuantity / item.Quantity;

                        item.OrgItemId = item.Id;
                        item.Id = IdWorkerUtils.Instance.NextId();
                        item.OrderId = _BackOrderObject.Id;
                        item.TradeNo = _BackOrderObject.TradeNo;
                        //单品优惠
                        foreach (PromotionItem promotion in item.Promotions)
                        {
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            promotion.OrderId = _BackOrderObject.Id;
                            promotion.ItemId = item.Id;
                            promotion.TradeNo = _BackOrderObject.TradeNo;

                            promotion.Amount = (0 - promotion.Amount) * rate;
                            promotion.DiscountAmount = (0 - promotion.DiscountAmount) * rate;
                            promotion.ReceivableAmount = (0 - promotion.ReceivableAmount) * rate;
                            promotion.FinishDate = finishDate;
                            promotion.RelationId = promotion.RelationId == "0" ? string.Empty : promotion.RelationId;
                        }
                        //做法信息
                        foreach (FlavorItem flavor in item.Flavors)
                        {
                            flavor.Id = IdWorkerUtils.Instance.NextId();
                            flavor.OrderId = _BackOrderObject.Id;
                            flavor.ItemId = item.Id;
                            flavor.TradeNo = _BackOrderObject.TradeNo;
                            flavor.isRefund = true;
                            flavor.OrderItemQuantity = refundQuantity;
                            flavor.RefundQuantity = refundQuantity;
                            flavor.Amount = flavor.Amount;
                            flavor.Quantity = flavor.Quantity;
                            flavor.DiscountAmount = 0 - flavor.DiscountAmount;
                            flavor.FinishDate = finishDate;
                            flavor.isBackTicket = true;
                        }

                        //清空支付方式分摊
                        item.ItemPayList = new List<OrderItemPay>();

                        item.MiddleRefundQuantity = refundQuantity;
                        item.RefundQuantity = refundQuantity;
                        item.Quantity = 0;
                        item.Amount = 0 - refundAmount;
                        item.FlavorAmount = 0 - item.FlavorAmount;
                        item.FlavorDiscountAmount = 0 - item.FlavorDiscountAmount;
                        item.FlavorReceivableAmount = 0 - item.FlavorReceivableAmount;
                        item.TotalAmonut = 0 - item.TotalAmonut;
                        item.SuitAddPrice = 0 - item.SuitAddPrice;
                        item.SuitAmount = 0 - item.SuitAmount;
                        item.SaleDate = finishDate;
                        item.ChudaQty = 0;
                        item.ChupinQty = 0;
                        item.ChuxianQty = 0;
                        item.KdsChupinQty = 0;
                        item.FinishDate = finishDate;

                        if (item.RowState == OrderRowState.套餐明)
                        {
                            var newItem = backOrderItems.FirstOrDefault(x => x.OrgItemId == item.ParentId);
                            if (newItem != null)
                            {
                                item.ParentId = newItem.Id;
                                item.Group = newItem.Id;
                            }
                        }
                        else
                        {
                            item.Group = item.Id;
                        }

                        //原单-更新退货数量
                        var oldItem = _OrderObject.Items.FirstOrDefault(x => x.Id == item.OrgItemId);
                        oldItem.MiddleRefundQuantity += refundQuantity;
                        if (oldItem.Flavors != null && oldItem.Flavors.Count > 0)
                        {
                            oldItem.Flavors.ForEach(x =>
                            {
                                x.RefundQuantity += x.BaseQuantity * refundQuantity;
                            });
                        }

                        //计算套餐主的做法金额
                        PromotionUtils.UpdateSuitMain(_BackOrderObject, item);

                        backOrderItems.Add(item);
                    }

                    _BackOrderObject.Items = backOrderItems;

                    #region subin 20230916 原本地订单退款中增加小程序退款，包括小程序单品退
                    //var newPayList = new List<PayItem>();
                    //subin 20230922 只有门店点餐[堂食、外带、餐桌]的退款，按照支付分摊退款
                    //if (OrderType.堂食 == _BackOrderObject.OrderType || OrderType.外带 == _BackOrderObject.OrderType || OrderType.餐桌 == _BackOrderObject.OrderType)
                    //{
                    //    //退款，全部按照支付分摊退款
                    //    newPayList = CalculatePay(_BackOrderObject, _OrderObject);
                    //}
                    ////else if (OrderType.微信点餐 == _BackOrderObject.OrderType)
                    ////{
                    ////    newPayList = CalculatePay(_BackOrderObject, _OrderObject);
                    ////}

                    //退款，全部按照支付分摊退款
                    //subin 20230922 注释
                    var newPayList = CalculatePay(_BackOrderObject, _OrderObject);

                    decimal diffAmount = 0 - _BackOrderObject.PaidAmount;

                    if (OrderType.微信点餐 == _BackOrderObject.OrderType)
                    {
                        diffAmount = 0 - _BackOrderObject.ReceivableAmount;
                    }

                    //支付方式遍历
                    foreach (PayItem pay in _BackOrderObject.Pays)
                    {
                        //if (OrderType.微信点餐 == _BackOrderObject.OrderType)
                        //{
                        //    diffAmount = 0 - pay.PaidAmount;
                        //}

                        //分摊新流程，按照分摊的金额进行扣款
                        PayItem sharePay = null;
                        if (newPayList != null && newPayList.Count > 0)
                        {
                            sharePay = newPayList.FirstOrDefault(x => x.OrgPayId == pay.Id);
                            if (sharePay == null)
                            {
                                //存在分摊，但是当前支付方式不在本次应退范围（上面计算的商品分摊），跳过
                                continue;
                            }
                        }

                        var oldPay = _OrderObject.Pays.FirstOrDefault(x => x.Id == pay.Id);

                        if (sharePay != null)
                        {
                            //启用了分摊，按照分摊中的支付进行扣款
                            pay.Id = sharePay.Id;

                            pay.Amount = sharePay.PaidAmount;
                            //当前支付方式余额
                            var balanceAmount = pay.PaidAmount - pay.RefundAmount;
                            if (Math.Abs(balanceAmount) < Math.Abs(pay.Amount))
                            {
                                //本次扣款不足，余额扣掉即可
                                pay.Amount = 0 - balanceAmount;
                            }
                            //除去代金券的剩余金额，每次应该减去代金券分摊金额
                            diffAmount -= (0 - pay.Amount);
                        }
                        else
                        {
                            //沿用旧的逻辑，按顺序扣款
                            pay.Id = IdWorkerUtils.Instance.NextId();

                            //当前支付方式余额
                            var balanceAmount = pay.PaidAmount - pay.RefundAmount;

                            diffAmount -= balanceAmount;
                            if (diffAmount >= 0)
                            {
                                //当前支付方式的金额不足，全部付款
                                pay.Amount = (0 - balanceAmount);
                            }
                            else
                            {
                                //足够，将剩余金额扣掉即可
                                pay.Amount = (0 - (balanceAmount + diffAmount));
                            }
                        }

                        pay.PaidAmount = pay.Amount;
                        pay.RefundAmount = 0M;
                        pay.TradeNo = _BackOrderObject.TradeNo;
                        pay.PayNo = OrderUtils.Instance.GeneratePayNo();
                        pay.OrderId = _BackOrderObject.Id;
                        pay.ChangeAmount = 0 - pay.ChangeAmount;
                        pay.PayTime = finishDate;
                        pay.FinishDate = finishDate;
                        pay.OverAmount = 0 - pay.OverAmount;
                        pay.ShiftName = _BackOrderObject.ShiftName;
                        pay.ShiftNo = _BackOrderObject.ShiftNo;

                        //记录当前支付方式的已退款金额
                        oldPay.RefundAmount += pay.PaidAmount * -1;

                        var tempRefundAmount = 0M;

                        tempRefundAmount = pay.PaidAmount * -1;

                        #region subin 20231003 注释修改
                        //注释 
                        //zhangy 2020-02-18 Add 档口结算信息赋默认值
                        //pay.Ext1 = "0";
                        //pay.Ext2 = "0"; 

                        //修改
                        pay.Ext1 = string.IsNullOrEmpty(pay.Ext1) ? "0" : pay.Ext1;
                        pay.Ext2 = string.IsNullOrEmpty(pay.Ext2) ? "0" : pay.Ext2;
                        #endregion

                        switch (pay.No)
                        {
                            case "49":
                            case "02"://会员卡
                                {
                                    this.ShowToastNotify(this, LangProxy.ToLang("正在进行会员卡退款...请勿关闭！"), 30000);
                                    CardTradeCancelRequest cardRequest = new CardTradeCancelRequest();
                                    cardRequest.TradeNo = _OrderObject.TradeNo;
                                    cardRequest.TicketNo = _BackOrderObject.TradeNo;
                                    cardRequest.TradeVoucherNo = pay.TradeVoucherNo;
                                    cardRequest.Reason = "正常退款";
                                    cardRequest.ShopNo = Global.Instance.Authc.StoreNo;
                                    cardRequest.WorkerNo = Global.Instance.Worker.No;
                                    cardRequest.PosNo = Global.Instance.Authc.PosNo;
                                    cardRequest.TotalAmount = (int)(tempRefundAmount * 100);
                                    var pointValue = CalculateRefundMemberPoint(_OrderObject, _BackOrderObject);
                                    cardRequest.TotalPoint = (int)(pointValue * 100);
                                    RefundCardInfo info = new RefundCardInfo();
                                    info.CardNo = pay.CardNo;
                                    info.Amount = (int)(tempRefundAmount * 100);
                                    List<RefundCardInfo> infoList = new List<RefundCardInfo>();
                                    infoList.Add(info);
                                    cardRequest.CardInfo = infoList;
                                    var result = CardUtils.CardTradeRefund(cardRequest);
                                    if (result.Item1)
                                    {
                                        var cancelObj = result.Item3;
                                        pay.TradeVoucherNo = cancelObj.RefNo;
                                        var card1 = cancelObj.CardList.FirstOrDefault(x => x.CardNo == pay.CardNo);
                                        if (card1 != null)
                                        {
                                            _BackOrderObject.PrePoint = card1.PrePoint;
                                            _BackOrderObject.AddPoint = 0 - card1.Point;
                                            _BackOrderObject.AftPoint = card1.AftPoint;
                                        }

                                        //_BackOrderObject.PrePoint = cancelObj.PreTotalPoint;
                                        //_BackOrderObject.AddPoint = 0 - cancelObj.TotalPoint;
                                        //_BackOrderObject.AftPoint = cancelObj.AftTotalPoint;

                                        foreach (var cancelItem in cancelObj.CardList)
                                        {
                                            var card = _BackOrderObject.Pays.Find(x => x.CardNo == cancelItem.CardNo);
                                            if (card != null)
                                            {
                                                card.CardAftAmount = cancelItem.AftAmount;
                                                card.CardBeforeBalance = cancelItem.PreAmount;
                                            }
                                        }

                                        _OrderObject.RefundPoint += pointValue;
                                    }
                                    else
                                    {
                                        return new Tuple<bool, string>(false, result.Item2);
                                    }
                                }
                                break;
                            case "03":
                                {

                                }
                                break;
                            case "04"://支付宝
                                {
                                    this.ShowToastNotify(this, LangProxy.ToLang("正在进行支付宝退款...请勿关闭！"), 30000);
                                    switch (pay.PayChannel)
                                    {
                                        case PayChannelEnum.原生支付:
                                            {
                                                var result = AlipayApi.RefundAndQuery(AccountTypeEnum.门店, pay.OutTradeNo, pay.Amount, _BackOrderObject.TradeNo, "正常退款");
                                                if (!result.Item1)
                                                {
                                                    return new Tuple<bool, string>(false, result.Item2);
                                                }
                                            }
                                            break;
                                        case PayChannelEnum.扫呗支付:
                                            {
                                                var res = SaobeiApi.GetSaobeiParameter(AccountTypeEnum.门店);
                                                if (res.Item1)
                                                {
                                                    var parameter = res.Item3;
                                                    //银联商务支付参数
                                                    string merchant_no = parameter.ContainsKey("merchant_no") ? parameter["merchant_no"].ToString() : "";
                                                    string terminal_id = parameter.ContainsKey("terminal_id") ? parameter["terminal_id"].ToString() : "";
                                                    string signKey = parameter.ContainsKey("signKey") ? parameter["signKey"].ToString() : "";
                                                    string gatewayUrl = parameter.ContainsKey("gatewayUrl") ? parameter["gatewayUrl"].ToString() : "";
                                                    string requestNum = string.Format("{0}_{1}", Global.Instance.Authc.StoreNo, _OrderObject.TradeNo);
                                                    SaobeiRefundParam request = new SaobeiRefundParam();
                                                    request.Pay_type = "020";
                                                    request.Terminal_trace = _BackOrderObject.TradeNo;
                                                    request.Refund_fee = string.Format("{0}", Convert.ToInt32(tempRefundAmount * 100));
                                                    request.Out_trade_no = pay.TradeVoucherNo;
                                                    var upayPayment = SaobeiUtils.SaobeiRefund(merchant_no, terminal_id, signKey, gatewayUrl, request);
                                                    if (!upayPayment.Item1)
                                                    {
                                                        return new Tuple<bool, string>(false, upayPayment.Item2);
                                                    }
                                                    else
                                                    {
                                                        pay.Memo = "扫呗支付:该订单已全额退款,";
                                                    }
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, res.Item2);
                                                }
                                            }
                                            break;
                                        case PayChannelEnum.乐刷支付:
                                            {
                                                var _data = PayMentOperation.RefundPay(pay);

                                                if (_data.Item1)
                                                {
                                                    pay.Memo = "乐刷支付:该订单已全额退款,";
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, _data.Item2);
                                                }
                                            }
                                            break;
                                        default:
                                            {
                                                return new Tuple<bool, string>(false, LangProxy.ToLang("暂未开放该渠道退款"));
                                            }
                                            break;
                                    }
                                }
                                break;
                            case "05"://微信支付
                                {
                                    this.ShowToastNotify(this, LangProxy.ToLang("正在进行微信退款...时间很长，预计1-2分钟，请勿关闭！"), 100000);
                                    switch (pay.PayChannel)
                                    {
                                        case PayChannelEnum.原生支付:
                                            {
                                                var result = WeixinApi.RefundAndQuery(AccountTypeEnum.门店, pay.OutTradeNo, pay.Amount, pay.Amount, _BackOrderObject.TradeNo, "正常退款", 100);
                                                if (!result.Item1)
                                                {
                                                    return new Tuple<bool, string>(false, result.Item2);
                                                }
                                            }
                                            break;
                                        case PayChannelEnum.扫呗支付:
                                            {
                                                var res = SaobeiApi.GetSaobeiParameter(AccountTypeEnum.门店);
                                                if (res.Item1)
                                                {
                                                    var parameter = res.Item3;
                                                    //银联商务支付参数
                                                    string merchant_no = parameter.ContainsKey("merchant_no") ? parameter["merchant_no"].ToString() : "";
                                                    string terminal_id = parameter.ContainsKey("terminal_id") ? parameter["terminal_id"].ToString() : "";
                                                    string signKey = parameter.ContainsKey("signKey") ? parameter["signKey"].ToString() : "";
                                                    string gatewayUrl = parameter.ContainsKey("gatewayUrl") ? parameter["gatewayUrl"].ToString() : "";
                                                    string requestNum = string.Format("{0}_{1}", Global.Instance.Authc.StoreNo, _OrderObject.TradeNo);
                                                    SaobeiRefundParam request = new SaobeiRefundParam();
                                                    request.Pay_type = "010";
                                                    request.Terminal_trace = _BackOrderObject.TradeNo;
                                                    request.Refund_fee = string.Format("{0}", Convert.ToInt32(tempRefundAmount * 100));
                                                    request.Out_trade_no = pay.TradeVoucherNo;
                                                    var upayPayment = SaobeiUtils.SaobeiRefund(merchant_no, terminal_id, signKey, gatewayUrl, request);
                                                    if (!upayPayment.Item1)
                                                    {
                                                        return new Tuple<bool, string>(false, upayPayment.Item2);
                                                    }
                                                    else
                                                    {
                                                        pay.Memo = "扫呗支付:该订单已全额退款,";
                                                    }
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, res.Item2);
                                                }
                                            }
                                            break;
                                        case PayChannelEnum.乐刷支付:
                                            {
                                                var _data = PayMentOperation.RefundPay(pay);

                                                if (_data.Item1)
                                                {
                                                    pay.Memo = "乐刷支付:该订单已全额退款,";
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, _data.Item2);
                                                }
                                            }
                                            break;
                                        default:
                                            {
                                                return new Tuple<bool, string>(false, "暂未开放该渠道退款");
                                            }
                                    }
                                }
                                break;
                            case "07":
                                {
                                    this.ShowToastNotify(this, LangProxy.ToLang("正在进行云闪付退款...请勿关闭！"), 30000);

                                    switch (pay.PayChannel)
                                    {
                                        case PayChannelEnum.扫呗支付:
                                            {
                                                var res = SaobeiApi.GetSaobeiParameter(AccountTypeEnum.门店);
                                                if (res.Item1)
                                                {
                                                    var parameter = res.Item3;
                                                    //银联商务支付参数
                                                    string merchant_no = parameter.ContainsKey("merchant_no") ? parameter["merchant_no"].ToString() : "";
                                                    string terminal_id = parameter.ContainsKey("terminal_id") ? parameter["terminal_id"].ToString() : "";
                                                    string signKey = parameter.ContainsKey("signKey") ? parameter["signKey"].ToString() : "";
                                                    string gatewayUrl = parameter.ContainsKey("gatewayUrl") ? parameter["gatewayUrl"].ToString() : "";
                                                    string requestNum = string.Format("{0}_{1}", Global.Instance.Authc.StoreNo, _OrderObject.TradeNo);
                                                    SaobeiRefundParam request = new SaobeiRefundParam();
                                                    request.Pay_type = "110";
                                                    request.Terminal_trace = _BackOrderObject.TradeNo;
                                                    request.Refund_fee = string.Format("{0}", Convert.ToInt32(tempRefundAmount * 100));
                                                    request.Out_trade_no = pay.TradeVoucherNo;
                                                    var upayPayment = SaobeiUtils.SaobeiRefund(merchant_no, terminal_id, signKey, gatewayUrl, request);
                                                    if (!upayPayment.Item1)
                                                    {
                                                        return new Tuple<bool, string>(false, upayPayment.Item2);
                                                    }
                                                    else
                                                    {
                                                        pay.Memo = "扫呗支付:该订单已全额退款,";
                                                    }
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, res.Item2);
                                                }
                                            }
                                            break;
                                        case PayChannelEnum.乐刷支付:
                                            {
                                                var _data = PayMentOperation.RefundPay(pay);

                                                if (_data.Item1)
                                                {
                                                    pay.Memo = "乐刷支付:该订单已全额退款,";
                                                }
                                                else
                                                {
                                                    return new Tuple<bool, string>(false, _data.Item2);
                                                }
                                            }
                                            break;
                                    }

                                }
                                break;
                            #region subin 2023-07-10 add 通联退款
                            case "50":
                                {
                                    var _payuserId = "";
                                    if (_BackOrderObject.OrderType == OrderType.微信点餐)
                                    {
                                        _payuserId = pay.OpenId;
                                    }
                                    var result = new Tuple<bool, string, string>(false, "", "");
                                    #region subin 20230918 由前端支付到统一账号，退款从统一账号退款改为分店账号收款分店账号退款
                                    //subin 20230920 门店付款由前端支付到统一账号，退款从统一账号退款，小程序分店账号收款分店账号退款                                    
                                    if (OrderType.堂食 == _BackOrderObject.OrderType || OrderType.外带 == _BackOrderObject.OrderType || OrderType.餐桌 == _BackOrderObject.OrderType)
                                    {
                                        result = AllinApi.RefundAndQuery(AccountTypeEnum.门店, _BackOrderObject.TradeNo, Convert.ToInt32(_OrderObject.PaidAmount * 100), Convert.ToInt32(tempRefundAmount * 100), _OrderObject.TradeNo, _BackOrderObject.RefundCause, _OrderObject.OrderType, _payuserId);
                                    }
                                    else if (OrderType.微信点餐 == _BackOrderObject.OrderType)
                                    {
                                        result = AllinApi.RefundAndQuery(AccountTypeEnum.门店, _BackOrderObject, _OrderObject.TradeNo, Convert.ToInt32(_OrderObject.PaidAmount * 100), _payuserId);
                                    }

                                    //if (result.Item1)
                                    //{
                                    //    _BackOrderObject.Pays.First(m => m.No == "50").OtherRate = 3M;
                                    //}

                                    #endregion

                                    if (!result.Item1)
                                    {
                                        return new Tuple<bool, string>(false, result.Item2);
                                    }
                                    else
                                    {
                                        //subin 20230927，根据通联退款接口返回手续费并保存至支付信息中
                                        //pay.Ext2=(decimal)result.Item2
                                        var _detail = JsonUtils.Deserialize<OrderDetail>(result.Item3);
                                        pay.Ext2 = ((decimal)_detail.fee) / 100 * -1 + "";
                                        pay.Memo = "通联支付:该订单已退款,";
                                    }
                                }
                                break;
                                #endregion
                        }

                        //subin 20231003 注释
                        //zhangy 2020-02-18 Add,增加退单的门店结算扣率处理逻辑
                        //档口结算信息赋默认值
                        //pay.Ext1 = "0";
                        //pay.Ext2 = "0";
                        //subin end

                        var payMode = OrderUtils.GetPayMode(pay.No);
                        if (payMode == null)
                        {
                            pay.IncomeFlag = 1;
                            pay.OtherRateType = 0;
                            pay.OtherRateValue = 0.00M;
                        }
                        else
                        {
                            pay.IncomeFlag = payMode.IncomeFlag;
                            pay.OtherRateType = payMode.OtherRateType;
                            pay.OtherRateValue = 0 - payMode.OtherRateValue;

                            //zhangy 2020-02-18 Add,退单，扣率金额也退
                            pay.Ext2 = string.IsNullOrEmpty(pay.Ext2) ? "0" : (pay.Ext2);
                        }

                    }

                    #endregion

                    //使用会员卡增加了积分，但是没有使用会员卡支付，需要单独调用退积分功能
                    if (_BackOrderObject.AddPoint < 0 && !_BackOrderObject.Pays.Exists(x => x.No == "02"))
                    {
                        var pointValue = CalculateRefundMemberPoint(_OrderObject, _BackOrderObject);
                        if (pointValue > 0)
                        {
                            this.ShowToastNotify(this, LangProxy.ToLang("正在进行会员卡退款...请勿关闭！"), 30000);
                            CardTradeCancelRequest cardRequest = new CardTradeCancelRequest();
                            cardRequest.TradeNo = _OrderObject.TradeNo;
                            cardRequest.TicketNo = _BackOrderObject.TradeNo;
                            cardRequest.Reason = "正常退款";
                            cardRequest.ShopNo = Global.Instance.Authc.StoreNo;
                            cardRequest.WorkerNo = Global.Instance.Worker.No;
                            cardRequest.PosNo = Global.Instance.Authc.PosNo;
                            //cardRequest.TotalAmount = 0;
                            cardRequest.TotalPoint = (int)(pointValue * 100);
                            //RefundCardInfo info = new RefundCardInfo();
                            //info.CardNo = _BackOrderObject.MemberNo;
                            //info.Amount = 0;
                            //List<RefundCardInfo> infoList = new List<RefundCardInfo>();
                            //infoList.Add(info);
                            //cardRequest.CardInfo = infoList;
                            var result = CardUtils.CardTradeRefund(cardRequest);
                            if (result.Item1)
                            {
                                if (result.Item3 != null)
                                {
                                    var cancelObj = result.Item3;
                                    _BackOrderObject.PrePoint = cancelObj.PreTotalPoint;
                                    _BackOrderObject.AddPoint = 0 - cancelObj.TotalPoint;
                                    _BackOrderObject.AftPoint = cancelObj.AftTotalPoint;

                                    _OrderObject.RefundPoint += cancelObj.TotalPoint;
                                }
                            }
                            else
                            {
                                return new Tuple<bool, string>(false, result.Item2);
                            }
                        }
                    }

                    //zhangy 2020-04-24 Add 美团券核销，退券
                    if (_BackOrderObject.Pays != null)
                    {
                        var couponList = _BackOrderObject.Pays.FindAll(x => "12".Equals(x.No)).ToList();
                        if (couponList.Count > 0)
                        {
                            //逐个退券
                            foreach (var coupon in couponList)
                            {
                                logger.Info("订单<{0}>发起退回美团券<{1}>", _BackOrderObject.TradeNo, coupon.TradeVoucherNo);

                                var request = new CouponCancelRequest();
                                request.VendorShopId = Global.Instance.Authc.StoreNo;
                                request.CouponCode = coupon.TradeVoucherNo;
                                request.EId = Global.Instance.Worker.No;
                                request.EName = Global.Instance.Worker.Name;

                                var result = MeituanCouponUtils.Instance.OrdeCancel(request);
                                logger.Info("订单<{0}>美团券<{1}>退回结果：{2}", _BackOrderObject.TradeNo, coupon.TradeVoucherNo, result.Item2);
                                if (result.Item1)
                                {
                                    //成功
                                    logger.Info("订单<{0}>美团券<{1}>退回成功", _BackOrderObject.TradeNo, coupon.TradeVoucherNo);
                                }
                                else
                                {
                                    //失败
                                    return new Tuple<bool, string>(false, result.Item2);
                                }
                            }
                        }
                    }

                    var isException = OrderUtils.Instance.SaveOrderObject(_BackOrderObject);
                    if (!isException)
                    {
                        _OrderObject.OrgTradeNo = _BackOrderObject.TradeNo;
                        var oldSplitPay = new SplitStorePay();
                        //更新订单明细的退货数量
                        using (var db = Global.Instance.OpenDataBase)
                        {
                            #region subin 20230921 退款成功后，更新原分账明细的退款金额
                            //var splitPayLst = db.Query<SplitStorePay>("where orderId=@0;", _OrderObject.Id);
                            #endregion

                            using (var trans = db.GetTransaction())
                            {
                                //保存原单更新信息
                                foreach (var item in _OrderObject.Items)
                                {
                                    db.Update(item, new string[] { "middleRefundQuantity" });

                                    //原明细支付分摊
                                    if (item.ItemPayList != null && item.ItemPayList.Count > 0)
                                    {
                                        foreach (var itemPay in item.ItemPayList)
                                        {
                                            db.Update(itemPay, new string[] { "ramount" });

                                            #region subin 20230921 退款成功后，更新原分账明细的退款金额
                                            //if (_OrderObject.OrderType == OrderType.堂食 || _OrderObject.OrderType == OrderType.外带 || _OrderObject.OrderType == OrderType.餐桌)
                                            //{
                                            //    var splitPay = splitPayLst.FirstOrDefault(m => m.OrderId == _OrderObject.Id && m.OrderItemId == item.Id && m.PayItemId == itemPay.Id);
                                            //    if (splitPay != null)
                                            //    {
                                            //        if (itemPay.RefundAmount > 0)
                                            //        {
                                            //            splitPay.IsRefund = 1;
                                            //            splitPay.RefundAmount += itemPay.RefundAmount;
                                            //            splitPay.RefundQuantity += item.MiddleRefundQuantity;
                                            //            db.Update(splitPay);
                                            //            LOGGER.Info($"堂食、外带、餐桌订餐退款成功后，更新原分账明细：{JsonUtils.Serialize(splitPay)}");

                                            //            if (!string.IsNullOrEmpty(splitPay.TicketId))
                                            //            {
                                            //                if (!string.IsNullOrEmpty(splitPay.Id))
                                            //                {
                                            //                    var api = new SplitPayApi();
                                            //                    var entity = new SplitStorePayEntity
                                            //                    {
                                            //                        Id = splitPay.Id,
                                            //                        ClientId = splitPay.ClientId,
                                            //                        ProgramId = splitPay.ProductId,
                                            //                        TenantId = splitPay.TenantId,
                                            //                        StoreId = splitPay.StoreId,
                                            //                        SplitStoreId = splitPay.SplitStoreId,
                                            //                        StoreNo = splitPay.StoreNo,
                                            //                        PayNo = splitPay.PayNo,
                                            //                        TicketId = splitPay.TicketId,
                                            //                        BusNo = splitPay.BusNo,
                                            //                        PayTypeNo = splitPay.PayTypeNo,
                                            //                        PayType = splitPay.PayType,
                                            //                        Paid = splitPay.Paid,
                                            //                        Rchange = splitPay.Rchange,
                                            //                        Money = splitPay.Money,
                                            //                        OverAmount = splitPay.OverAmount,
                                            //                        VoucherNo = splitPay.VoucherNo,
                                            //                        PayDate = splitPay.PayDate,
                                            //                        CardNo = splitPay.CardNo,
                                            //                        IncomeFlag = splitPay.IncomeFlag,
                                            //                        OtherRateType = splitPay.OtherRateType,
                                            //                        OtherRateValue = splitPay.OtherRateValue,
                                            //                        OtherRate = splitPay.OtherRate,
                                            //                        PayClientType = splitPay.PayClientType,
                                            //                        PayChannel = splitPay.PayChannel,
                                            //                        DeductionRate = splitPay.DeductionRate,
                                            //                        ChargeBack = splitPay.ChargeBack,
                                            //                        Memo = splitPay.Memo,
                                            //                        IsInvalid = splitPay.IsInvalid,
                                            //                        OrderId = splitPay.OrderId,
                                            //                        OrderItemId = splitPay.OrderItemId,
                                            //                        PayId = splitPay.PayId,
                                            //                        PayItemId = splitPay.PayItemId,
                                            //                        SyncStatus = splitPay.SyncStatus,
                                            //                        UploadErrors = splitPay.UploadErrors,
                                            //                        UploadStatus = splitPay.UploadStatus,
                                            //                        UploadMessage = splitPay.UploadMessage,
                                            //                        ProductId = splitPay.ProductId,
                                            //                        RefundAmount = splitPay.RefundAmount,
                                            //                        FromBizUserld = splitPay.FromBizUserld,
                                            //                        OrderType = splitPay.OrderType,
                                            //                        IsRefund = splitPay.IsRefund,
                                            //                        Quantity = splitPay.Quantity,
                                            //                        RefundQuantity = splitPay.RefundQuantity,
                                            //                        TableNo = _OrderObject.TableNo,
                                            //                        People = _OrderObject.People.ToString(),
                                            //                        OrdTicketId = _OrderObject.TicketId,
                                            //                        WorkerNo = _OrderObject.WorkerNo,
                                            //                        UploadErrCode = splitPay.UploadErrCode,
                                            //                        UploadErrMessage = splitPay.UploadErrMessage,
                                            //                        UploadTime = splitPay.UploadTime,
                                            //                        fee = splitPay.fee,
                                            //                        Goodid = splitPay.ProductId,
                                            //                        //UnitPrice=""
                                            //                    };
                                            //                    var result = api.UpdateSplitPay(entity);
                                            //                    if (result.Item1)
                                            //                    {
                                            //                        LOGGER.Info($"退款成功后，更新服务端原分账信息：成功");
                                            //                    }
                                            //                    else
                                            //                    {
                                            //                        LOGGER.Info($"退款成功后，更新服务端原分账信息：失败");
                                            //                    }
                                            //                }
                                            //            }

                                            //            Thread.Sleep(10);
                                            //        }
                                            //    }
                                            //}

                                            #endregion
                                        }


                                    }

                                    if (item.Flavors != null && item.Flavors.Count > 0)
                                    {
                                        foreach (var flavor in item.Flavors)
                                        {
                                            db.Update(flavor, new string[] { "refund" });
                                        }
                                    }

                                    //明细促销
                                    if (item.Promotions != null && item.Promotions.Count > 0)
                                    {
                                        foreach (var pro in item.Promotions)
                                        {
                                            //db.Update(pro, new string[] { "refundFlag" });
                                        }
                                    }
                                }



                                foreach (var pay in _OrderObject.Pays)
                                {
                                    db.Update(pay, new string[] { "ramount" });
                                }

                                db.Update(_OrderObject);


                                #region subin 20230921 退款成功后，更新原分账明细的退款金额
                                //if (_OrderObject.OrderType == OrderType.微信点餐)
                                //{
                                //    foreach (var item in backOrderItems)
                                //    {
                                //        var splitPay = splitPayLst.FirstOrDefault(m => m.OrderId == _OrderObject.Id && m.ProductId == item.ProductId);
                                //        if (splitPay != null)
                                //        {
                                //            splitPay.IsRefund = 1;
                                //            splitPay.RefundAmount += backOrderItems.Find(m => m.ProductId == splitPay.ProductId).TotalAmonut * -1;
                                //            splitPay.RefundQuantity = item.MiddleRefundQuantity;
                                //            db.Update(splitPay);

                                //            LOGGER.Info($"小程序退款成功后，更新原分账明细：{JsonUtils.Serialize(splitPay)}");

                                //            if (!string.IsNullOrEmpty(splitPay.TicketId))
                                //            {
                                //                if (!string.IsNullOrEmpty(splitPay.Id))
                                //                {
                                //                    var api = new SplitPayApi();
                                //                    var entity = new SplitStorePayEntity
                                //                    {
                                //                        Id = splitPay.Id,
                                //                        ClientId = splitPay.ClientId,
                                //                        ProgramId = splitPay.ProductId,
                                //                        TenantId = splitPay.TenantId,
                                //                        StoreId = splitPay.StoreId,
                                //                        SplitStoreId = splitPay.SplitStoreId,
                                //                        StoreNo = splitPay.StoreNo,
                                //                        PayNo = splitPay.PayNo,
                                //                        TicketId = splitPay.TicketId,
                                //                        BusNo = splitPay.BusNo,
                                //                        PayTypeNo = splitPay.PayTypeNo,
                                //                        PayType = splitPay.PayType,
                                //                        Paid = splitPay.Paid,
                                //                        Rchange = splitPay.Rchange,
                                //                        Money = splitPay.Money,
                                //                        OverAmount = splitPay.OverAmount,
                                //                        VoucherNo = splitPay.VoucherNo,
                                //                        PayDate = splitPay.PayDate,
                                //                        CardNo = splitPay.CardNo,
                                //                        IncomeFlag = splitPay.IncomeFlag,
                                //                        OtherRateType = splitPay.OtherRateType,
                                //                        OtherRateValue = splitPay.OtherRateValue,
                                //                        OtherRate = splitPay.OtherRate,
                                //                        PayClientType = splitPay.PayClientType,
                                //                        PayChannel = splitPay.PayChannel,
                                //                        DeductionRate = splitPay.DeductionRate,
                                //                        ChargeBack = splitPay.ChargeBack,
                                //                        Memo = splitPay.Memo,
                                //                        IsInvalid = splitPay.IsInvalid,
                                //                        OrderId = splitPay.OrderId,
                                //                        OrderItemId = splitPay.OrderItemId,
                                //                        PayId = splitPay.PayId,
                                //                        PayItemId = splitPay.PayItemId,
                                //                        SyncStatus = splitPay.SyncStatus,
                                //                        UploadErrors = splitPay.UploadErrors,
                                //                        UploadStatus = splitPay.UploadStatus,
                                //                        UploadMessage = splitPay.UploadMessage,
                                //                        ProductId = splitPay.ProductId,
                                //                        RefundAmount = splitPay.RefundAmount,
                                //                        FromBizUserld = splitPay.FromBizUserld,
                                //                        OrderType = splitPay.OrderType,
                                //                        IsRefund = splitPay.IsRefund,
                                //                        Quantity = splitPay.Quantity,
                                //                        RefundQuantity = splitPay.RefundQuantity,
                                //                        TableNo = _OrderObject.TableNo,
                                //                        People = _OrderObject.People.ToString(),
                                //                        OrdTicketId = _OrderObject.TicketId,
                                //                        WorkerNo = _OrderObject.WorkerNo,
                                //                        UploadErrCode = splitPay.UploadErrCode,
                                //                        UploadErrMessage = splitPay.UploadErrMessage,
                                //                        UploadTime = splitPay.UploadTime,
                                //                        fee = splitPay.fee,
                                //                        Goodid = splitPay.ProductId,
                                //                        //UnitPrice=""
                                //                    };
                                //                    var result = api.UpdateSplitPay(entity);
                                //                    if (result.Item1)
                                //                    {
                                //                        LOGGER.Info($"退款成功后，更新服务端原分账信息：成功");
                                //                    }
                                //                    else
                                //                    {
                                //                        LOGGER.Info($"退款成功后，更新服务端原分账信息：失败");
                                //                    }
                                //                }
                                //            }

                                //            Thread.Sleep(10);
                                //        }
                                //    }
                                //}
                                #endregion

                                #region subin 20231008 退款成功后，找到原分账明细中有手续费的数据，更新手续费。
                                //subin 20231008 退款成功后，找到原分账明细中有手续费的数据，更新手续费。
                                //var oldSplitPayas = splitPayLst.Where(m => m.OrderId == _OrderObject.Id && m.Pid != null);
                                //oldSplitPay = oldSplitPayas.FirstOrDefault(m => m.fee > 0);
                                //if (oldSplitPay != null)
                                //{
                                //    LOGGER.Info($"退款成功后，返还原分账手续费，原订单手续费：{oldSplitPay.fee}，退还手续费：{Math.Abs(Convert.ToDecimal(_BackOrderObject.Pays[0].Ext2))}");
                                //    oldSplitPay.fee -= Math.Abs(Convert.ToDecimal(_BackOrderObject.Pays[0].Ext2));
                                //    db.Update(oldSplitPay);
                                //    LOGGER.Info($"退款成功后，更新本地原分账信息：{JsonUtils.Serialize(oldSplitPay)}");
                                //}
                                //var oldPSplitPay = db.First<SplitStorePay>("where (pid is null or pid='') and orderId=@0;", _OrderObject.Id);
                                //if (oldPSplitPay != null)
                                //{
                                //    oldPSplitPay.IsRefund = 1;
                                //    oldPSplitPay.fee -= Math.Abs(Convert.ToDecimal(_BackOrderObject.Pays[0].Ext2));
                                //    db.Update(oldPSplitPay);
                                //} 
                                #endregion

                                trans.Complete();
                            }
                        }



                        LOGGER.Info("开始打印");
                        this.ShowToastNotify(this, LangProxy.ToLang("正在打印退款单..."));
                        //开始打印
                        _BackOrderObject.PrintType = 1;
                        _BackOrderObject.RPrint = false;

                        //退单厨打开关
                        bool allowChuda = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_TUIDAN_CHUDA, false);

                        List<PrintTypeEnum> printList = new List<PrintTypeEnum>();
                        printList.Add(PrintTypeEnum.小票);
                        if (allowChuda)
                        {
                            printList.Add(PrintTypeEnum.厨打);
                        }
                        //退单出品开关
                        bool allowChupin = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_TUIDAN_CHUPIN, false);
                        if (allowChupin)
                        {
                            printList.Add(PrintTypeEnum.出品);
                        }

                        this.PrintOrderObject(_BackOrderObject, printList);

                        #region subin 20231008 退款成功后，更新服务端分账手续费
                        //if (oldSplitPay != null)
                        //{
                        //    if (!string.IsNullOrEmpty(oldSplitPay.TicketId) && oldSplitPay.SyncStatus == 1)
                        //    {
                        //        var api = new SplitPayApi();
                        //        if (!string.IsNullOrEmpty(oldSplitPay.Id))
                        //        {
                        //            var entity = new SplitStorePayEntity
                        //            {
                        //                Id = oldSplitPay.Id,
                        //                ClientId = oldSplitPay.ClientId,
                        //                ProgramId = oldSplitPay.ProductId,
                        //                TenantId = oldSplitPay.TenantId,
                        //                StoreId = oldSplitPay.StoreId,
                        //                SplitStoreId = oldSplitPay.SplitStoreId,
                        //                StoreNo = oldSplitPay.StoreNo,
                        //                PayNo = oldSplitPay.PayNo,
                        //                TicketId = oldSplitPay.TicketId,
                        //                BusNo = oldSplitPay.BusNo,
                        //                PayTypeNo = oldSplitPay.PayTypeNo,
                        //                PayType = oldSplitPay.PayType,
                        //                Paid = oldSplitPay.Paid,
                        //                Rchange = oldSplitPay.Rchange,
                        //                Money = oldSplitPay.Money,
                        //                OverAmount = oldSplitPay.OverAmount,
                        //                VoucherNo = oldSplitPay.VoucherNo,
                        //                PayDate = oldSplitPay.PayDate,
                        //                CardNo = oldSplitPay.CardNo,
                        //                IncomeFlag = oldSplitPay.IncomeFlag,
                        //                OtherRateType = oldSplitPay.OtherRateType,
                        //                OtherRateValue = oldSplitPay.OtherRateValue,
                        //                OtherRate = oldSplitPay.OtherRate,
                        //                PayClientType = oldSplitPay.PayClientType,
                        //                PayChannel = oldSplitPay.PayChannel,
                        //                DeductionRate = oldSplitPay.DeductionRate,
                        //                ChargeBack = oldSplitPay.ChargeBack,
                        //                Memo = oldSplitPay.Memo,
                        //                IsInvalid = oldSplitPay.IsInvalid,
                        //                OrderId = oldSplitPay.OrderId,
                        //                OrderItemId = oldSplitPay.OrderItemId,
                        //                PayId = oldSplitPay.PayId,
                        //                PayItemId = oldSplitPay.PayItemId,
                        //                SyncStatus = oldSplitPay.SyncStatus,
                        //                UploadErrors = oldSplitPay.UploadErrors,
                        //                UploadStatus = oldSplitPay.UploadStatus,
                        //                UploadMessage = oldSplitPay.UploadMessage,
                        //                ProductId = oldSplitPay.ProductId,
                        //                RefundAmount = oldSplitPay.RefundAmount,
                        //                FromBizUserld = oldSplitPay.FromBizUserld,
                        //                OrderType = oldSplitPay.OrderType,
                        //                IsRefund = oldSplitPay.IsRefund,
                        //                Quantity = oldSplitPay.Quantity,
                        //                RefundQuantity = oldSplitPay.RefundQuantity,
                        //                TableNo = _OrderObject.TableNo,
                        //                People = _OrderObject.People.ToString(),
                        //                OrdTicketId = _OrderObject.TicketId,
                        //                WorkerNo = _OrderObject.WorkerNo,
                        //                UploadErrCode = oldSplitPay.UploadErrCode,
                        //                UploadErrMessage = oldSplitPay.UploadErrMessage,
                        //                UploadTime = oldSplitPay.UploadTime,
                        //                fee = oldSplitPay.fee,
                        //                Goodid = oldSplitPay.ProductId,
                        //                //UnitPrice=""
                        //            };
                        //            var result = api.UpdateSplitPay(entity);
                        //            if (result.Item1)
                        //            {
                        //                LOGGER.Info($"退款成功后，更新服务端原分账手续费：成功");
                        //            }
                        //            else
                        //            {
                        //                LOGGER.Info($"退款成功后，更新服务端原分账手续费：失败");
                        //            }
                        //        }
                        //    }
                        //} 
                        

                        //Task.Factory.StartNew(() =>
                        //{
                        //    SplitPayUtils.Instance.UpdateRefund(_OrderObject, _BackOrderObject);
                        //});

                        #endregion

                        return new Tuple<bool, string>(true, LangProxy.ToLang("退单完成"));
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, LangProxy.ToLang("退单保存失败！"));
                    }
                }
                else
                {
                    return new Tuple<bool, string>(false, LangProxy.ToLang("获取订单信息异常"));
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "退单发生异常");
                if (ex is WebException || ex is SocketException)
                {
                    return new Tuple<bool, string>(false, "连接退款平台失败");
                }

                return new Tuple<bool, string>(false, LangProxy.ToLang("退单发生异常"));
            }
        }

        /// <summary>
        /// 计算退积分数量
        /// </summary>
        /// <param name="orgOrder"></param>
        /// <param name="refundOrder"></param>
        /// <returns></returns>
        public decimal CalculateRefundMemberPoint(OrderObject orgOrder, OrderObject refundOrder)
        {
            //判断是否为最后一次退货
            bool lastRefund = false;
            foreach (var orgItem in orgOrder.Items)
            {
                var refundItem = refundOrder.Items.FirstOrDefault(x => x.OrgItemId == orgItem.Id);
                if (orgItem.Quantity == orgItem.MiddleRefundQuantity)
                {
                    lastRefund = true;
                }
                else
                {
                    lastRefund = false;
                    break;
                }
            }

            decimal refundPoint = decimal.Zero;
            if (orgOrder.UsableRefundPoint > 0)
            {
                //最后一次退积分，直接取剩余积分
                if (lastRefund)
                {
                    refundPoint = orgOrder.UsableRefundPoint;
                }
                else
                {
                    foreach (var refundItem in refundOrder.Items)
                    {
                        var orgItem = orgOrder.Items.FirstOrDefault(x => x.Id == refundItem.OrgItemId);
                        if (orgItem != null)
                        {
                            var rate = refundItem.Amount * -1 / orgOrder.Amount;
                            //部分退，按比例退，积分不积小数，向下取整
                            decimal point = Math.Floor(orgOrder.UsableRefundPoint * rate);
                            refundPoint += point;
                        }
                    }
                }
            }
            return refundPoint;
        }

        /// <summary>
        /// 退单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_backTicket_Click(object sender, EventArgs e)
        {
            string permissionCode = "10043";

            var action = new Action(() =>
            {

                this.RefundOrderCheck();

            });

            var ret = AuthzUtils.Instance.CheckAuthz(this, "退单", permissionCode, action);

            if (!ret.Item1)
            {
                this.ShowToastNotify(this, ret.Item2);
            }
        }

        private void Reprinter()
        {
            var panel = salesListTable.PrimaryGrid;
            if (panel.ActiveRow == null)
            {
                this.ShowToastNotify(this, LangProxy.ToLang("请选择要操作的单据"));
                return;
            }

            //选择补打的内容
            RePrintSelectForm form = new RePrintSelectForm();
            form.AcceptButtonClick += (o, args) =>
            {
                var printType = (PrintTypeEnum)Enum.Parse(typeof(PrintTypeEnum), args.Data.ToString());

                var row = panel.ActiveRow as GridRow;
                var tradeNo = row.Cells["busNo"].Value.ToString();

                OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo(tradeNo);
                if (_OrderObject.OrderType == OrderType.美团外卖 || _OrderObject.OrderType == OrderType.饿了么 || _OrderObject.OrderType == OrderType.百度外卖)
                {

                    this.ShowToastNotify(this, LangProxy.ToLang("第三方外卖的单据请到外卖历史订单补打！"));
                    return;
                }
                if (_OrderObject.OrderType == OrderType.微信点餐)
                {

                    this.ShowToastNotify(this, LangProxy.ToLang("微信点餐的单据请到微信历史订单补打！"));
                    return;
                }
                if (_OrderObject != null)
                {
                    _OrderObject.PrintType = 0;
                    _OrderObject.RPrint = true;

                    List<PrintTypeEnum> printList = new List<PrintTypeEnum>();
                    printList.Add(printType);
                    this.PrintOrderObject(_OrderObject, printList);

                }
                else
                {
                    this.ShowToastNotify(this, LangProxy.ToLang("获取订单信息异常"));
                }
            };

            form.ShowDialog();

        }
        /// <summary>
        /// 补打账单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_TicketPrint_Click(object sender, EventArgs e)
        {
            string permissionCode = "10044";

            var action = new Action(() =>
            {

                this.Reprinter();

            });

            var ret = AuthzUtils.Instance.CheckAuthz(this, "补打", permissionCode, action);

            if (!ret.Item1)
            {
                this.ShowToastNotify(this, ret.Item2);
            }

        }

        private void OnControlBoxMinClick(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }
        /// <summary>
        /// 营业模式变化
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cb_change_click(object sender, EventArgs e)
        {
            var obj = sender as CheckBoxX;
            var indexT = obj.Tag as string;
            if ("全部".Equals(indexT))
            {
                orderType = -1;
            }
            if ("堂食".Equals(indexT))
            {
                orderType = 0;
            }
            if ("外带".Equals(indexT))
            {
                orderType = 1;
            }
            if ("电话外卖".Equals(indexT))
            {
                orderType = 2;
            }
            if ("餐桌".Equals(indexT))
            {
                orderType = 3;
            }
            if ("美团外卖".Equals(indexT))
            {
                orderType = 4;
            }
            if ("饿了么".Equals(indexT))
            {
                orderType = 5;
            }
            if ("百度外卖".Equals(indexT))
            {
                orderType = 6;
            }
            if ("微信点餐".Equals(indexT))
            {
                orderType = 7;
            }
            this.txtTradeNo.Focus();
            this.txtTradeNo.SelectAll();
            QueryTicket();
        }
        /// <summary>
        /// 输入单号查询
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnFinishedClick(object sender, Component.EnterEventArg e)
        {
            QueryTicket();
        }

        /// <summary>
        /// 打印订单
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        private bool PrintOrderObject(OrderObject orderObject, List<PrintTypeEnum> typeList)
        {
            bool isException = false;

            try
            {
                foreach (var type in typeList)
                {
                    switch (type)
                    {
                        case PrintTypeEnum.小票:
                            {
                                logger.Info(string.Format("收银员<{0}>补打订单小票<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                //收银小票打印
                                Task.Factory.StartNew(() =>
                                {
                                    //构建收银小票模版参数
                                    List<VariableValue> vars = null;
                                    if (orderObject.PrintType == 0 && orderObject.OrderType == OrderType.电话外卖)
                                    {
                                        //补打电话外卖结账单，退单走普通
                                        vars = PrintHelper.BuilderDeliveryTicketVariable(orderObject);
                                    }
                                    else
                                    {
                                        vars = PrintHelper.BuilderTicketVariable(orderObject);
                                    }

                                    //自动切纸
                                    bool cutPager = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_CASHIER_ALLOW_CUT_PAGER, false);
                                    //是否允许打开钱箱 补打单、退单不开钱箱
                                    bool openCashbox = false;

                                    //票头空白行
                                    int headerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_HEADER_EMPTY, 0);

                                    //票尾空白行
                                    int footerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_FOOTER_EMPTY, 0);

                                    if (orderObject.PrintType == 0)
                                    {
                                        //执行收银小票打印
                                        switch (orderObject.OrderType)
                                        {
                                            case OrderType.电话外卖:
                                                {
                                                    logger.Info("开始打印电话外送小票<{0}>", orderObject.TradeNo);
                                                    var prt = PrintHelper.PrinterTicket("电话外卖", vars, cutPager, false, headerLine, footerLine);
                                                    logger.Info("补打电话外送小票打印结果<{0},{1},{2}>", orderObject.TradeNo, prt.Item1, prt.Item2);
                                                }
                                                break;
                                            default:
                                                {
                                                    logger.Info("开始打印收银小票<{0}>", orderObject.TradeNo);
                                                    var prt = PrintHelper.PrinterTicket("收银小票", vars, cutPager, openCashbox, headerLine, footerLine);
                                                    logger.Info("补打小票打印结果<{0},{1},{2}>", orderObject.TradeNo, prt.Item1, prt.Item2);
                                                }
                                                break;
                                        }
                                    }
                                    else
                                    {
                                        //退单统一走结账单小票模板
                                        logger.Info("开始打印退款收银小票<{0}>", orderObject.TradeNo);
                                        var prt = PrintHelper.PrinterTicket("收银小票", vars, cutPager, openCashbox, headerLine, footerLine);
                                        logger.Info("退款小票打印结果<{0},{1},{2}>", orderObject.TradeNo, prt.Item1, prt.Item2);
                                    }

                                });
                            }
                            break;
                        case PrintTypeEnum.标签:
                            {
                                //打印标签
                                logger.Info(string.Format("收银员<{0}>补打订单标签<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                Task.Factory.StartNew(() =>
                                {
                                    LabelPrintHelper.PrintOrderLabel(orderObject);
                                });
                            }
                            break;
                        case PrintTypeEnum.厨打:
                            {
                                //厨打小票打印
                                logger.Info(string.Format("收银员<{0}>补打订单厨打<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                Task.Factory.StartNew(() =>
                                {
                                    ChuDaHelper.KitchenPrinter(orderObject);
                                });
                            }
                            break;
                        case PrintTypeEnum.厨打标签:
                            {
                                //厨打小票打印
                                logger.Info(string.Format("收银员<{0}>补打订单厨打标签<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                Task.Factory.StartNew(() =>
                                {
                                    ChuDaHelper.KitchenLabelPrinter(orderObject);
                                });
                            }
                            break;
                        case PrintTypeEnum.出品:
                            {
                                //出品小票打印
                                logger.Info(string.Format("收银员<{0}>补打订单出品<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                Task.Factory.StartNew(() =>
                                {
                                    ChuDaHelper.MadePrinter(orderObject);
                                });
                            }
                            break;
                        case PrintTypeEnum.厨显:
                            {
                                //通知厨显
                                logger.Info(string.Format("收银员<{0}>补打订单厨显<{1}>", Global.Instance.Worker.No, orderObject.TradeNo));
                                Task.Factory.StartNew(() =>
                                {
                                    UploadSCNewOrder.UploadNewOrder2SC4KDS(orderObject);
                                });
                            }
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                isException = true;

                LOGGER.Error(ex, "打印订单信息异常");
            }
            return isException;
        }

        /// <summary>
        /// 农商行MIS打印
        /// </summary>
        private void AbmcsPrint()
        {

            string fileName = string.Format(@"Abmcs\{0}", "Print.txt");
            string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);
            if (File.Exists(filePath))
            {
                string[] lines = File.ReadAllLines(filePath, System.Text.Encoding.Default);
                var sb = new StringBuilder();

                var pobject = PrintHelper.GetTicketPrinterObject(true, false); ;

                List<PrintContent> content = new List<PrintContent>();

                for (int i = 0; i < lines.Length; i++)
                {
                    var str = lines[i];
                    switch (str)
                    {
                        case "CUTPAPER":
                            {
                                logger.Info("打印小票切纸动作");

                                //切纸
                                var p = new PrintContent();
                                p.Format = RowFormat.Line;
                                p.Content = new StringBuilder().Append(ParseEscPosCommand("29,86,66"));

                                content.Add(p);
                            }
                            break;

                        default:
                            {
                                var p = new PrintContent();

                                p.Format = RowFormat.Line;
                                p.Content = new StringBuilder().Append(str);
                                p.AlignStyle = AlignStyle.居左;
                                p.FontStyle = Printer.FontStyle.正常字体;
                                p.BitmapFile = string.Empty;

                                content.Add(p);

                                logger.Info(str);
                            }
                            break;
                    }
                }
                if (true)
                {
                    //切纸
                    var p = new PrintContent();
                    p.Format = RowFormat.Line;
                    p.Content = new StringBuilder().Append(ParseEscPosCommand("29,86,66"));

                    content.Add(p);
                }
                //启动新任务
                Task.Factory.StartNew(() =>
                {
                    PrinterUtils.PrintContent(pobject, content);
                });
            }
            else
            {
                logger.Warn(filePath + "不存在");
            }
        }


        /// <summary>
        /// 建行MIS打印
        /// </summary>
        private void Print()
        {
            string fileName = string.Format(@"landiccbmispos\{0}", "P_TackSingle.txt");
            string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);
            if (File.Exists(filePath))
            {
                string[] lines = File.ReadAllLines(filePath, System.Text.Encoding.Default);
                var sb = new StringBuilder();

                var pobject = PrintHelper.GetTicketPrinterObject(true, false); ;

                List<PrintContent> content = new List<PrintContent>();

                for (int i = 0; i < lines.Length; i++)
                {
                    var str = lines[i];
                    switch (str)
                    {
                        case "#CUT#":
                            {
                                logger.Info("打印小票切纸动作");

                                //切纸
                                var p = new PrintContent();
                                p.Format = RowFormat.Line;
                                p.Content = new StringBuilder().Append(ParseEscPosCommand("29,86,66"));

                                content.Add(p);
                            }
                            break;
                        case "#LDSIGN#":
                            {
                                logger.Info("打印ElecSign.bmp签名图片");
                            }
                            break;
                        case "#ODBMP#":
                            {
                                logger.Info("打印ConsumeOD.bmp图片");
                            }
                            break;
                        case "#QRBMP#":
                            {
                                logger.Info("打印PublicQR.bmp图片");
                            }
                            break;
                        default:
                            {
                                var p = new PrintContent();

                                p.Format = RowFormat.Line;
                                p.Content = new StringBuilder().Append(str);
                                p.AlignStyle = AlignStyle.居左;
                                p.FontStyle = Printer.FontStyle.正常字体;
                                p.BitmapFile = string.Empty;

                                content.Add(p);

                                logger.Info(str);
                            }
                            break;
                    }
                }
                if (true)
                {
                    //切纸
                    var p = new PrintContent();
                    p.Format = RowFormat.Line;
                    p.Content = new StringBuilder().Append(ParseEscPosCommand("29,86,66"));

                    content.Add(p);
                }
                //启动新任务
                Task.Factory.StartNew(() =>
                {
                    PrinterUtils.PrintContent(pobject, content);
                });
            }
            else
            {
                logger.Warn(filePath + "不存在");
            }
        }

        private string ParseEscPosCommand(string command)
        {
            string[] array = command.Split(',');
            List<byte> bytList = new List<byte>();
            foreach (var s in array)
            {
                bytList.Add(Convert.ToByte(s.Trim()));
            }
            return Encoding.Default.GetString(bytList.ToArray());
        }
        /// <summary>
        /// 加载绑定数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnBind(object sender, GridDataBindingCompleteEventArgs e)
        {
            var panel = e.GridPanel;

            foreach (var r in panel.Rows)
            {
                var row = r as GridRow;

                //设置单据内容字体颜色
                if ("已退单".Equals(row.Cells["status"].Value.ToString()) && decimal.Parse(row.Cells["amount"].Value.ToString()) <= decimal.Zero)
                {
                    row.CellStyles.Default.TextColor = Color.Red;
                }
                else
                {
                    row.CellStyles.Default.TextColor = Color.Black;
                }
                //var payTypeNo = row.Cells["payTypeNo"].Value.ToString();
                //if ("合计".Equals(payTypeNo))
                //{
                //    row.CellStyles.Default.Background.Color1 = Color.AliceBlue;

                //    row.CellStyles.Default.Font = new Font("宋体", 14.75f, FontStyle.Bold, GraphicsUnit.Pixel);
                //}

            }
        }

        /// <summary>
        ///  中行退款
        /// </summary>
        /// <param name="_orderObject">订单数据</param>
        /// <param name="_paytype">支付类型</param>
        /// <param name="Outtrading">退款要素</param>
        private void SoftPosAPI(OrderObject _orderObject, string _paytype, string Outtrading)
        {
            try
            {
                LOGGER.Info("↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓进入中行退款模块↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓");
                SoftPosPay _softPosPay = new SoftPosPay();

                RequestData request = new RequestData();
                request.PosNo = Global.Instance.BusinessPlanLog.PosNo;
                request.PayType = _paytype;
                request.PayAmount = _orderObject.ReceivableAmount.ToString();
                request.OperatorNo = Global.Instance.Worker.No;
                request.Outtrading = Outtrading;
                request.ContentType = " R";

                var _data = _softPosPay.InitiateConsumption(request);

                if (_data.Code == Proxy.Common.ReturnState.Failed)
                {
                    this.ShowToastNotify(this, LangProxy.ToLang("中行退款失败！"));

                }
                else
                {
                    this.ShowToastNotify(this, LangProxy.ToLang("退款成功！"));
                }
                LOGGER.Info("↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑离开中行退款模块↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑");
            }
            catch (Exception ex)
            {
                LOGGER.Info("↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓中行退款异常↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓");
                LOGGER.Info(ex);
                LOGGER.Info("↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑中行退款异常↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑");
            }

        }

        private void buttonX11_Click(object sender, EventArgs e)
        {
            //var isException = SplitPayUtils.Instance.Order2Split(this.startPicker.Value);
            //LOGGER.Info($"↑↑↑手动分账[{this.startPicker.Value.ToString("yyyy-MM-dd")}]结果：{isException}↑↑↑");
            //var result = SplitPayUtils.Instance.SplitData2Server();
            //LOGGER.Info($"↑↑↑手动分账[{this.startPicker.Value.ToString("yyyy-MM-dd")}]上传结果：{result.Item1}↑↑↑");

            #region subin 20231025 分账由实时改为交班时分账
            splitFrm = new SplitPayUploadForm(0, 100);
            this.Invoke(new EventJisuan(SplitHandle), sender, e);
            #endregion
        }

        #region subin 20231025 分账由实时改为交班时分账
        delegate void EventJisuan(object sender, EventArgs e);
        SplitPayUploadForm splitFrm;

        protected virtual void MessageEventNotify(object sender, MsgEventArgs args)
        {
            int pos = Convert.ToInt32(args.Data);
            splitFrm.setPos(pos);//设置进度条位置20%
        }

        private void SplitHandle(object sender, EventArgs e)
        {
            splitFrm.Show(this);
            splitFrm.setPos(0);//设置进度条位置0%

            //需要加载进度的内容
            var isException = SplitPayUtils.Instance.Order2Split(this.startPicker.Value);
            if (isException)
            {
                LOGGER.Info($"↓↓↓日订单[{DateTime.Now.ToString("yyyy-MM-dd")}]转分账数据失败↓↓↓");
                DialogForm dialog = new DialogForm("提示信息", $"日订单[{DateTime.Now.ToString("yyyy-MM-dd")}]数据处理失败");
                dialog.Show();
            }
            splitFrm.setPos(20);//设置进度条位置0%

            #region 上传分账记录
            var result1 = SplitPayUtils.Instance.SplitData2Server(this.startPicker.Value);
            if (result1.Item1)
            {
                LOGGER.Info($"↓↓↓日订单[{DateTime.Now.ToString("yyyy-MM-dd")}]分账数据上传完成完成↓↓↓");
            }
            else
            {
                LOGGER.Info($"↓↓↓日订单[{DateTime.Now.ToString("yyyy-MM-dd")}]分账数据上传完成失败↓↓↓");
                DialogForm dialog = new DialogForm("提示信息", $"日订单[{DateTime.Now.ToString("yyyy-MM-dd")}]数据上传失败");
                dialog.Show();
            }
            splitFrm.setPos(100);//设置进度条位置0%
            Thread.Sleep(100);
            splitFrm.Close();
            #endregion
        }
        #endregion
    }
}