using DevComponents.DotNetBar;
using DevComponents.DotNetBar.Controls;
using NLog;
using POSV.Component;
using POSV.Entity;
using POSV.Helper;
using POSV.MessageEvent;
using POSV.MsgCenter;
using POSV.OtherWaiMai;
using POSV.Utils;
using POSV.ServiceCenter;
using POSV.ShoppingCart;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace POSV.QiMai
{
    public partial class QiMaiForm : BusinessForm
    {
        private int orderType = 0;//订单类型
        private int SelectType = 0;//待处理订单

        private bool generalQuerying = false;//历史订单查询锁
        private bool handleQuerying = false;//待处理订单查询锁

        private bool isBudanFlag = false;//是否正在进行补单操作

        /// <summary>
        /// 1-自动接单；0-手动接单
        /// </summary>
        private int ConfirmType = 0;

        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public QiMaiForm()
        {
            InitializeComponent();

            this.dateInputPicker.Value = DateTime.Now.Date;
            //是否开启自动接单
            bool openConfirm = Global.Instance.GlobalConfigBoolValue(ConfigConstant.QIMAI_CONFIRM_PARAMETER, false);
            if (openConfirm)
            {
                ConfirmType = 1;
                this.radioButtonOpen.Checked = true;

                this.superTabControl1.SelectedTabIndex = 1;
            }
            else
            {
                ConfirmType = 0;
                this.radioButtonClose.Checked = true;

                this.superTabControl1.SelectedTabIndex = 0;
            }
        }

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

            //注册结算支付事件通知
            MsgEvent.RemoveListener(Constant.QM_WEIXIN_UI_UPDATA, this.OrderUIEventNotify);
            MsgEvent.Receive(Constant.QM_WEIXIN_UI_UPDATA, this.OrderUIEventNotify);

            this.checkBoxX0.Checked = true;
            //第一步加载门店信息
            QueryQiMaiShopInfo();
            ////第二步,获取待处理订单
            //POSV.Proxy.Mqtt.MqttClientUtils.Instance.OnMessageReceived -= Instance_OnMessageReceived;
            //POSV.Proxy.Mqtt.MqttClientUtils.Instance.OnMessageReceived += Instance_OnMessageReceived;
            DoHandQuery();
        }

        protected virtual void OrderUIEventNotify(object sender, MsgEventArgs args)
        {

            if (this.InvokeRequired)
            {
                this.Invoke((EventHandler)delegate
                {
                    var data = args.Data.ToString();
                    //堂食或者开启自动接单，跳转到历史订单
                    if ("qimai_tx".Equals(data) || ConfirmType == 1)
                    {
                        this.superTabControl1.SelectedTabIndex = 1;
                        //加载待处理订单
                        DoQuery(1, pagerControl2.RowsPerPage); 
                    }
                    else
                    {
                        this.superTabControl1.SelectedTabIndex = 0;
                        //加载待处理订单
                        DoHandQuery();
                    }
                    
                });
            }
        }

        /// <summary>
        /// 门店门店信息
        /// </summary>
        private void QueryQiMaiShopInfo()
        {
            Task.Factory.StartNew(() =>
            {
                QiMaiShopQueryRequest request = new QiMaiShopQueryRequest();
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                var response = QiMaiUtils.QiMaiShopQuery(request);
                if (response != null && response.Item1)
                {
                    if (this.IsDisposed || !this.IsHandleCreated) return;
                    this.Invoke(new Action(() =>
                    {
                        var responseMessage = response.Item3;
                        if (responseMessage != null && responseMessage.Data != null)
                        {
                            QiMaiShopQueryResponse PoiInfo = responseMessage.Data;
                            this.StoreNameLabelX.Text = PoiInfo.Name;//门店名称
                            switch (PoiInfo.Status)
                            {
                                case 0:
                                    this.isOpenLabelX.Text = "门店休息";
                                    break;
                                case 1:
                                    this.isOpenLabelX.Text = "营业中";
                                    break;
                                default:
                                    this.isOpenLabelX.Text = "未营业";
                                    break;
                            }
                            var TimeLab = "";
                            foreach (QiMaiSaletime saletime in PoiInfo.Saletimes) {
                                foreach (QiMaiWorktime worktime in saletime.Worktime) {
                                    TimeLab += worktime.Time.ToString().Replace("[","").Replace("]", "").Replace("\"","").Replace("\r","").Replace("\n", "").Trim();
                                }
                            }
                            this.openTimeLabelX.Text = TimeLab;
                        }
                    }));
                }
            });
        }

        //private void Instance_OnMessageReceived(object sender, POSV.Proxy.Mqtt.MessageEventArgs e)
        //{
            
        //    try
        //    {
        //        string message = e.Message;
        //        int type = e.Type;

        //        logger.Info("处理企迈订单Type={0},Message={0}", type, message);

        //        if (type == 0)
        //        {
        //            Dictionary<string, string> messageMap = JsonUtils.Deserialize<Dictionary<string, string>>(message);
        //            if (messageMap.ContainsKey("qimai") && !"".Equals(messageMap["qimai"]))
        //            {
        //                DoHandQuery();
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        LOGGER.Error(ex);
        //    }
        //}

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

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

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

        /// <summary>
        /// 待处理订单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnOrderHand(object sender, EventArgs e)
        {
            DoHandQuery();
        }

        /// <summary>
        /// 历史订单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnQuery(object sender, EventArgs e)
        {
            DoQuery(1, pagerControl2.RowsPerPage);
        }

        /// <summary>
        /// 日期查询
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnTimeClick(object sender, EventArgs e)
        {
            var obj = sender as TouchButtonX;
            var date = obj.Tag as string;
            switch (date)
            {
                case "today":
                    this.dateInputPicker.Value = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd"));
                    break;
                case "yesterday":
                    this.dateInputPicker.Value = DateTime.Parse(DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd"));
                    break;
            }
            DoQuery(1, pagerControl2.RowsPerPage);
        }

        /// <summary>
        /// 订单状态选择
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CbstatusChangeClick(object sender, EventArgs e)
        {
            var obj = sender as CheckBoxX;
            var indexT = obj.Tag as string;
            if ("全部".Equals(indexT))
            {
                orderType = 0;
            }
            if ("已取消".Equals(indexT))
            {
                orderType = 1;
            }
            if ("已退单".Equals(indexT))
            {
                orderType = 2;
            }
            DoQuery(1, pagerControl2.RowsPerPage);
        }

        /// <summary>
        /// 是否自动接单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CbChangeClick(object sender, EventArgs e)
        {
            var obj = sender as CheckBoxX;
            var indexT = obj.Tag as string;
            int type = 0;
            if ("开启".Equals(indexT) && obj.Checked)
            {
                ConfirmType = 1;
            }
            if ("关闭".Equals(indexT) && obj.Checked)
            {
                ConfirmType = 0;
            }
            var config = new Config();

            config.Id = IdWorkerUtils.Instance.NextId();
            config.Group = ConfigConstant.DEVICE_GROUP;
            config.TenantId = Global.Instance.Authc.TenantId;
            config.Keys = ConfigConstant.QIMAI_CONFIRM_PARAMETER;
            config.Values = string.Format("{0}", ConfirmType);
            try
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    using (var trans = db.GetTransaction())
                    {
                        db.Save(config);

                        trans.Complete();
                    }
                }
                Global.Instance.ReloadConfig(ConfigConstant.DEVICE_GROUP);
                if (ConfirmType == 1)
                {
                    this.ShowToastNotify(this, "开启自动接单");
                }
                else
                {
                    this.ShowToastNotify(this, "关闭自动接单");
                }

            }
            catch (Exception ex)
            {
                string message = "微信订单参数更新异常";
                LOGGER.Error(ex, message);
            }
        }

        private void OnQueryPageChangeWithObject(object obj)
        {
            //获得当前页
            int cur = pagerControl2.CurrentPage;
            //获得每页显示的记录数
            int rows = pagerControl2.RowsPerPage;

            PagerControl pager = obj as PagerControl;
            if (pager != null)
            {
                DoQuery(cur, rows);
            }
        }

        private void TabOnclick(object sender, EventArgs e)
        {
            var obj = sender as SuperTabItem;
            var name = obj.Tag as string;
            switch (name)
            {
                case "superTabItem1"://待处理订单
                    SelectType = 0;
                    DoHandQuery();

                    break;
                case "superTabItem2"://历史订单
                    SelectType = 1;
                    DoQuery(1, pagerControl2.RowsPerPage);

                    break;
            }
        }

        //根据待处理订单的数量刷新提示
        public void sendNewView(int orderCount)
        {
            //有企迈小程序订单，发送界面数字角标
            MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity()
            {
                Subject = Constant.MENU_TITLE_CHANGED_NOTIFY,
                SubSubject = ModuleKeyCode.QM小程序订单.ToString(),
                Operate = MsgEntityOperate.发布,
                Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.QM小程序订单, MenuTileNotifyType.数量, string.Format("{0}", orderCount))
            });
        }

        private void DoQuery(int pageNum, int pageSize)
        {
            if (generalQuerying)
            {
                this.ShowToastNotify(this, "查询中.....");
                return;
            }
            generalQuerying = true;
            this.tableLayoutPanel2.Controls.Clear();
            Task.Factory.StartNew(() =>
            {
                QiMaiQrderListRequest request = new QiMaiQrderListRequest();
                string orderDate = this.dateInputPicker.Text;
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                request.PageNumber = pageNum;
                request.PageSize = pageSize;
                request.OrderDate = orderDate;
                request.Type = orderType;

                var response = QiMaiUtils.QiMaiQrderList(request);
                if (response != null && response.Item1)
                {
                    if (this.IsDisposed || !this.IsHandleCreated) return;
                    this.Invoke(new Action(() =>
                    {
                        List<QiMaiItem> detailList = new List<QiMaiItem>();
                        int handCount = 0;
                        foreach (QiMaiOrder order in response.Item3.List)
                        {
                            if (order.FinalStatus == 2)
                            {
                                handCount = handCount + 1;
                            }
                            var item = new QiMaiItem(order);
                            item.OnReceive += Item_OnReceive;
                            item.OnRefuseReceive += Item_OnRefuseReceive;
                            item.OnAgreereFund += Item_OnAgreereFund;
                            item.OnRefusereRund += Item_OnRefusereRund;
                            item.OnOrderPrint += Item_OnPrint;
                            item.OnOrderBuDan += Item_OnBuDan;
                            detailList.Add(item);
                        }

                        if (this.IsDisposed || !this.IsHandleCreated) return;
                        //更新控件
                        //sendNewView(handCount);
                        if (detailList.Count > 0)
                        {
                            this.tableLayoutPanel2.Controls.AddRange(detailList.ToArray());
                            //滚动至顶部
                            this.tableLayoutPanel2.AutoScrollPosition = new Point(0, 0);

                        }
                        this.pagerControl2.TotalPage = response.Item3.PageCount;
                        this.pagerControl2.CurrentPage = response.Item3.PageNumber;
                        this.pagerControl2.RecordCount = response.Item3.TotalCount;
                        this.pagerControl2.RowsPerPage = response.Item3.PageSize;
                    }));
                }

                generalQuerying = false;
            });
        }

        /// <summary>
        /// 订单打印
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnPrint(object sender, QiMaiOrderEventArgs e)
        {
            Task.Factory.StartNew(() =>
            {
                string orderId = e.OrderId;
                QiMaiOrderRequest request = new QiMaiOrderRequest();
                string orderDate = this.dateInputPicker.Text;
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                request.OrderId = orderId;
                var response = QiMaiUtils.QiMaiOrderInfo(request);
                if (response != null && response.Item1)
                {
                    this.ShowToastNotify(this, "开始打印");
                    //构建收银小票模版参数
                    var vars = WaiMaiHelper.BuilderQiMaiVariable(response.Item3.Data, true);
                    Tuple<bool, string> result = WaiMaiHelper.PrinterTicket("在线订单", vars);
                    this.ShowToastNotify(this, string.Format("{0}", result.Item2));
                    //组装本地数据
                    OrderObject orderObject = OtherWaiMaiApi.getOrderLocalQiMai(response.Item3.Data);
                    //打印标签
                    LabelPrintHelper.PrintOrderLabel(orderObject);
                    //启用外卖商品绑定厨显方案
                    var planKds = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_OTHERWAIMAI_PLANKDS, true);
                    //启用外卖商品绑定厨打方案
                    var planKit = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_OTHERWAIMAI_PLANKIT, true);
                    if (planKit)
                    {
                        //执行厨打
                        ChuDaHelper.KitchenPrinter(orderObject);
                        logger.Info("微信订单(QM)厨打成功");
                        //执行出品
                        ChuDaHelper.MadePrinter(orderObject);
                        logger.Info("微信订单(QM)出品成功");
                    }
                    if (planKds)
                    {
                        //通知厨显
                        UploadSCNewOrder.UploadNewOrder2SC4KDS(orderObject);
                        logger.Info("微信订单(QM)厨显成功");
                    }
                }
            });
        }

        /// <summary>
        /// 订单拒绝退单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnRefusereRund(object sender, QiMaiOrderEventArgs e)
        {
            string orderId = e.OrderId;
            QiMaiOrderRefuseRefundRequest request = new QiMaiOrderRefuseRefundRequest();
            request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
            request.OrderId = orderId;
            request.Reason = "您订购的饭菜已出餐,不能退款";
            var response = QiMaiUtils.QiMaiOrderRefuseRefund(request);
            if (response != null)
            {
                LOGGER.Info("微信外卖订单拒绝退单:" + response.Item2);
                this.ShowToastNotify(this, response.Item2);
                if (response.Item1)
                {
                    switch (SelectType)
                    {
                        case 0:
                            DoHandQuery();
                            break;
                        case 1:
                            DoQuery(1, pagerControl2.RowsPerPage);
                            break;
                    }

                }
            }
        }
        /// <summary>
        /// 订单接受退单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnAgreereFund(object sender, QiMaiOrderEventArgs e)
        {
            string orderId = e.OrderId;
            string orderNo = e.OrderNo;
            decimal amount = e.Amount;
            int typeCate = e.TypeCate;
            Tuple<bool, string, QiMaiEntityResponse<QiMaiOrderAgreeRefundResponse>> response = null;
            if (typeCate==1 || typeCate == 2) {
                QiMaiOrderRefundRequest request = new QiMaiOrderRefundRequest();
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                request.OrderId = orderId;
                request.OrderNo = orderNo;
                request.Amount = amount;
                response = QiMaiUtils.QiMaiOrderRefund(request);
            }
            else {
                QiMaiOrderAgreeRefundRequest request = new QiMaiOrderAgreeRefundRequest();
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                request.OrderId = orderId;
                response = QiMaiUtils.QiMaiOrderAgreeRefund(request);
            }
            if (response != null)
            {
                LOGGER.Info("企迈外卖订单同意退单:" + response.Item2);
                this.ShowToastNotify(this, response.Item2);
                if (response.Item1)
                {
                    //退单业务处理,退单处理退本地单
                    this.DoRefund("7" + orderId);
                    switch (SelectType)
                    {
                        case 0:
                            DoHandQuery();
                            break;
                        case 1:
                            DoQuery(1, pagerControl2.RowsPerPage);
                            break;
                    }

                }
            }

        }

        private Tuple<bool, string> DoRefund(string tradeNo)
        {
            try
            {
                OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo(tradeNo);
                if (_OrderObject != null)
                {
                    if (_OrderObject.OrgTradeNo != null && !"".Equals(_OrderObject.OrgTradeNo))
                    {
                        return new Tuple<bool, string>(false, "订单已完全退单");
                    }
                    //生成新单
                    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();
                    _BackOrderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();
                    _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;
                    //整单优惠
                    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;
                    }
                    //====== 更新明细内容
                    foreach (OrderItem item in _BackOrderObject.Items)
                    {
                        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;
                            promotion.DiscountAmount = 0 - promotion.DiscountAmount;
                            promotion.ReceivableAmount = 0 - promotion.ReceivableAmount;
                            promotion.FinishDate = finishDate;
                        }
                        //做法信息
                        foreach (FlavorItem flavor in item.Flavors)
                        {
                            flavor.Id = IdWorkerUtils.Instance.NextId();
                            flavor.OrderId = _BackOrderObject.Id;
                            flavor.ItemId = item.Id;
                            flavor.TradeNo = _BackOrderObject.TradeNo;
                            flavor.RefundQuantity = flavor.Quantity;
                            flavor.Amount = 0 - flavor.Amount;
                            flavor.Quantity = 0;
                            flavor.DiscountAmount = 0 - flavor.DiscountAmount;
                            flavor.FinishDate = finishDate;
                            flavor.isBackTicket = true;
                            flavor.isWaiMaiTicket = true;
                        }
                        item.RefundQuantity = item.Quantity;
                        item.Quantity = 0;
                        item.Amount = 0 - item.Amount;
                        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;

                    }
                    //支付方式遍历
                    foreach (PayItem pay in _BackOrderObject.Pays)
                    {
                        pay.Id = IdWorkerUtils.Instance.NextId();
                        pay.TradeNo = _BackOrderObject.TradeNo;
                        pay.PayNo = OrderUtils.Instance.GeneratePayNo();
                        pay.OrderId = _BackOrderObject.Id;
                        pay.Amount = 0 - pay.Amount;
                        pay.PaidAmount = 0 - pay.PaidAmount;
                        pay.ChangeAmount = 0 - pay.ChangeAmount;
                        pay.PayTime = finishDate;
                        pay.FinishDate = finishDate;
                        pay.OverAmount = 0 - pay.OverAmount;
                        pay.ShiftName = _BackOrderObject.ShiftName;
                        pay.ShiftNo = _BackOrderObject.ShiftNo;


                    }

                    //zhangy 2020-02-20Add SaveOrderObject默认自动添加结算参数计算
                    var isException = OrderUtils.Instance.SaveOrderObject(_BackOrderObject);
                    if (!isException)
                    {
                        _OrderObject.OrgTradeNo = _BackOrderObject.TradeNo;
                        using (var db = Global.Instance.OpenDataBase)
                        {
                            using (var trans = db.GetTransaction())
                            {
                                db.Update(_OrderObject);

                                trans.Complete();
                            }
                        }
                        return new Tuple<bool, string>(true, "退单完成");
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, "退单保存失败！");
                    }
                }
                else
                {
                    return new Tuple<bool, string>(false, "获取订单信息异常");
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "退单发生异常");
                return new Tuple<bool, string>(false, "退单发生异常");
            }
        }
        
        /// <summary>
        /// 订单接单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnReceive(object sender, QiMaiOrderEventArgs e)
        {
            LOGGER.Info("微信手动接单");
            string orderId = e.OrderId;
            OrderOnReceive(orderId);
        }

        /// <summary>
        /// 订单接单
        /// </summary>
        /// <param name="orderId"></param>
        public void OrderOnReceive(string orderId) {
            QiMaiOrderReceiveRequest request = new QiMaiOrderReceiveRequest();
            request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
            request.OrderId = orderId;
            var response = QiMaiUtils.QiMaiOrderReceive(request);
            if (response != null)
            {
                LOGGER.Info("在线订单接单:" + response.Item2);
                this.ShowToastNotify(this, response.Item2);
                if (response.Item1)
                {
                    try
                    {
                        //接单成功打印订单
                        QiMaiOrderRequest request1 = new QiMaiOrderRequest();
                        string orderDate = this.dateInputPicker.Text;
                        request1.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                        request1.OrderId = orderId;
                        var response1 = QiMaiUtils.QiMaiOrderInfo(request1);
                        if (response1 != null && response1.Item1)
                        {
                            OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo("7" + orderId);
                            if (_OrderObject != null)
                            {

                                LOGGER.Info("在线订单已存在");
                                return;
                            }
                            //组装本地数据
                            OrderObject orderObject = OtherWaiMaiApi.getOrderLocalQiMai(response1.Item3.Data);
                            logger.Info("微信订单组装完成");
                            lock (Global.Instance.SyncLock)
                            {
                                using (var db = Global.Instance.OpenDataBase)
                                {
                                    using (var trans = db.GetTransaction())
                                    {
                                        //整单
                                        db.Insert<OrderObject>(orderObject);

                                        foreach (OrderItem item in orderObject.Items)
                                        {
                                            ProductSpec productSpec = Global.ProductSpec._productSpecList.Find(x => x.Id.Equals(item.SpecId) && x.ProductId.Equals(item.ProductId));
                                            if (productSpec != null)
                                            {
                                                item.CostPrice = productSpec.CostPrice;
                                            }
                                            else
                                            {
                                                item.CostPrice = 0.00M;
                                            }
                                        }
                                        //单品明细
                                        db.InsertBatch<OrderItem>(orderObject.Items);
                                        //单品优惠
                                        if (orderObject.Items != null)
                                        {

                                            foreach (var promotion in orderObject.Items)
                                            {
                                                if (promotion.Promotions != null && promotion.Promotions.Count > 0)
                                                {
                                                    db.InsertBatch<PromotionItem>(promotion.Promotions);
                                                }
                                            }
                                        }
                                        //添加支付汇总的必填字段
                                        foreach (PayItem payItem in orderObject.Pays)
                                        {
                                            //档口结算信息赋默认值
                                            payItem.Ext1 = "0";
                                            payItem.Ext2 = "0";

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

                                                //zhangy 2020-02-20 Add 添加结算参数计算
                                                OrderUtils.SetPayModeDiscount(payItem, payMode);
                                            }
                                        }
                                        //支付明细
                                        db.InsertBatch<PayItem>(orderObject.Pays);
                                        //做法明细
                                        foreach (var flavor in orderObject.Items)
                                        {
                                            if (flavor.Flavors.Count > 0)
                                            {
                                                db.InsertBatch<FlavorItem>(flavor.Flavors);
                                            }
                                        }
                                        //如果是外卖订单,存储配送信息
                                        if (orderObject.OrderType == OrderType.微信点餐 && response1.Item3.Data.TypeCate == 3)
                                        {
                                            WxWaimaiOrder wxWaimaiOrder = new WxWaimaiOrder();
                                            wxWaimaiOrder.Id = IdWorkerUtils.Instance.NextId();
                                            wxWaimaiOrder.TenantId = orderObject.TenantId;
                                            wxWaimaiOrder.TicketNo = orderObject.TradeNo;
                                            wxWaimaiOrder.StoreId = orderObject.StoreId;
                                            wxWaimaiOrder.StoreNo = orderObject.StoreNo;
                                            wxWaimaiOrder.StoreName = orderObject.StoreName;
                                            wxWaimaiOrder.WorkerNo = orderObject.WorkerNo;
                                            wxWaimaiOrder.ShiftId = Global.Instance.BusinessPlanLog.PlanId;
                                            wxWaimaiOrder.ShiftNo = Global.Instance.BusinessPlanLog.No;
                                            wxWaimaiOrder.ReceiveName = response1.Item3.Data.AcceptName;
                                            wxWaimaiOrder.ReceiveMobile = response1.Item3.Data.AcceptMobile;
                                            wxWaimaiOrder.ReceiveAddress = response1.Item3.Data.Address;
                                            wxWaimaiOrder.DistributionFee = response1.Item3.Data.Freight;
                                            wxWaimaiOrder.Type = response1.Item3.Data.Express;
                                            if (wxWaimaiOrder.Type == 0)
                                            {
                                                wxWaimaiOrder.IsIncome = 1;
                                            }
                                            else
                                            {
                                                wxWaimaiOrder.IsIncome = 0;
                                            }
                                            wxWaimaiOrder.Status = 0;
                                            wxWaimaiOrder.CreateDate = orderObject.FinishDate;
                                            wxWaimaiOrder.CreateUser = orderObject.CreateUser;
                                            db.Insert<WxWaimaiOrder>(wxWaimaiOrder);
                                        }
                                        //8、保存耗料信息
                                        List<OrderProductBurden> orderBurdenList = new List<OrderProductBurden>();

                                        //第一步组装耗料数量
                                        foreach (var item in orderObject.Items)
                                        {
                                            //第一步先看看商品是否是管理库存的直销品
                                            var lists = Global.Product._productList;
                                            var selectProduct = new List<ProductExt>();
                                            selectProduct = lists.FindAll(x => x.Id.Equals(item.ProductId));
                                            if (selectProduct != null && selectProduct.Count > 0)
                                            {
                                                ProductExt productExt = selectProduct[0];
                                                if (productExt.StockFlag == 1)
                                                {
                                                    OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                    orderProductBurden.OrderId = orderObject.Id;
                                                    orderProductBurden.TenantId = orderObject.TenantId;
                                                    orderProductBurden.TradeNo = orderObject.TradeNo;
                                                    orderProductBurden.BurdenProductId = item.ProductId;
                                                    orderProductBurden.BurdenSpecId = item.SpecId;
                                                    orderProductBurden.SalesUnitId = item.ProductUnitId;
                                                    orderProductBurden.SalesAmount = item.Quantity - item.RefundQuantity;
                                                    orderBurdenList.Add(orderProductBurden);
                                                }
                                            }
                                            //第二步获取门店耗料
                                            StringBuilder sqlBuf = new StringBuilder();
                                            sqlBuf.Append("select burdenProductId,burdenSpecId,salesUnitId,salesAmount from  pos_product_burden where productId='{0}' and specId='{1}'");
                                            string productBurdenSql = string.Format(sqlBuf.ToString(), item.ProductId, item.SpecId);
                                            List<ProductBurden> productBurdenList = db.Query<ProductBurden>(productBurdenSql).ToList();
                                            if (productBurdenList != null && productBurdenList.Count > 0)
                                            {
                                                foreach (ProductBurden productBurden in productBurdenList)
                                                {
                                                    OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                    orderProductBurden.OrderId = orderObject.Id;
                                                    orderProductBurden.TenantId = orderObject.TenantId;
                                                    orderProductBurden.TradeNo = orderObject.TradeNo;
                                                    orderProductBurden.BurdenProductId = productBurden.BurdenProductId;
                                                    orderProductBurden.BurdenSpecId = productBurden.BurdenSpecId;
                                                    orderProductBurden.SalesUnitId = productBurden.SalesUnitId;
                                                    orderProductBurden.SalesAmount = productBurden.SalesAmount * (item.Quantity - item.RefundQuantity);
                                                    orderBurdenList.Add(orderProductBurden);
                                                }

                                            }
                                            //做法耗料
                                            foreach (var flavorItem in item.Flavors)
                                            {
                                                StringBuilder sqlBuf1 = new StringBuilder();
                                                sqlBuf1.Append("select burdenProductId,burdenSpecId,salesUnitId,salesAmount from  pos_make_burden where makeId='{0}'");
                                                string makeBurdenSql = string.Format(sqlBuf1.ToString(), flavorItem.MakeId);
                                                List<MakeBurden> makeBurdenList = db.Query<MakeBurden>(makeBurdenSql).ToList();
                                                if (makeBurdenList != null && makeBurdenList.Count > 0)
                                                {
                                                    foreach (MakeBurden makeBurden in makeBurdenList)
                                                    {
                                                        OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                        orderProductBurden.OrderId = orderObject.Id;
                                                        orderProductBurden.TenantId = orderObject.TenantId;
                                                        orderProductBurden.TradeNo = orderObject.TradeNo;
                                                        orderProductBurden.BurdenProductId = makeBurden.BurdenProductId;
                                                        orderProductBurden.BurdenSpecId = makeBurden.BurdenSpecId;
                                                        orderProductBurden.SalesUnitId = makeBurden.SalesUnitId;
                                                        orderProductBurden.SalesAmount = makeBurden.SalesAmount * (flavorItem.Quantity - flavorItem.RefundQuantity);
                                                        orderBurdenList.Add(orderProductBurden);
                                                    }

                                                }
                                            }
                                        }
                                        //第二部合并耗料数量
                                        if (orderBurdenList != null && orderBurdenList.Count > 0)
                                        {
                                            List<OrderProductBurden> temList = orderBurdenList.OrderBy(x => x.BurdenSpecId).ToList();
                                            Dictionary<string, Object> typeMap = new Dictionary<string, Object>();
                                            string burdenProductId_temp = "";
                                            string burdenSpecId_temp = "";
                                            string salesUnitId_temp = "";
                                            int i = 0;
                                            List<Dictionary<string, Object>> result = new List<Dictionary<string, Object>>();
                                            decimal salesAmount = 0.00M;
                                            int listLength = temList.Count;
                                            foreach (OrderProductBurden orderProductBurden in temList)
                                            {
                                                string burdenSpecId = orderProductBurden.BurdenSpecId;
                                                if (!burdenSpecId_temp.Equals(burdenSpecId))
                                                {
                                                    if (i != 0)
                                                    {
                                                        typeMap.Add("orderId", orderProductBurden.OrderId);
                                                        typeMap.Add("tenantId", orderProductBurden.TenantId);
                                                        typeMap.Add("tradeNo", orderProductBurden.TradeNo);
                                                        typeMap.Add("burdenProductId", burdenProductId_temp);
                                                        typeMap.Add("burdenSpecId", burdenSpecId_temp);
                                                        typeMap.Add("salesUnitId", salesUnitId_temp);
                                                        typeMap.Add("salesAmount", salesAmount);
                                                        result.Add(typeMap);
                                                        //分类改变时,清除缓存
                                                        typeMap = new Dictionary<string, Object>();
                                                    }
                                                    salesAmount = 0.00M;
                                                    burdenProductId_temp = orderProductBurden.BurdenProductId;
                                                    burdenSpecId_temp = orderProductBurden.BurdenSpecId;
                                                    salesUnitId_temp = orderProductBurden.SalesUnitId;
                                                }
                                                salesAmount = salesAmount + orderProductBurden.SalesAmount;
                                                i = i + 1;
                                                if (i == listLength)
                                                {
                                                    typeMap.Add("orderId", orderProductBurden.OrderId);
                                                    typeMap.Add("tenantId", orderProductBurden.TenantId);
                                                    typeMap.Add("tradeNo", orderProductBurden.TradeNo);
                                                    typeMap.Add("burdenProductId", burdenProductId_temp);
                                                    typeMap.Add("burdenSpecId", burdenSpecId_temp);
                                                    typeMap.Add("salesUnitId", salesUnitId_temp);
                                                    typeMap.Add("salesAmount", salesAmount);
                                                    result.Add(typeMap);
                                                    //分类改变时,清除缓存
                                                    typeMap = new Dictionary<string, Object>();
                                                }
                                            }
                                            List<OrderProductBurden> list = new List<OrderProductBurden>();
                                            foreach (Dictionary<string, Object> map in result)
                                            {
                                                OrderProductBurden entity = new OrderProductBurden();
                                                entity.Id = IdWorkerUtils.Instance.NextId();
                                                entity.StoreId = orderObject.StoreId;
                                                entity.OrderId = StringUtils.GetString(map["orderId"]);
                                                entity.TenantId = StringUtils.GetString(map["tenantId"]);
                                                entity.TradeNo = StringUtils.GetString(map["tradeNo"]);
                                                entity.BurdenProductId = StringUtils.GetString(map["burdenProductId"]);
                                                entity.BurdenSpecId = StringUtils.GetString(map["burdenSpecId"]);
                                                entity.SalesUnitId = StringUtils.GetString(map["salesUnitId"]);
                                                entity.SalesAmount = StringUtils.GetDecimal(map["salesAmount"]);
                                                list.Add(entity);

                                            }
                                            db.InsertBatch<OrderProductBurden>(list);
                                        }
                                        //更新是否有订单需要上传的状态
                                        LOGGER.Info("有需要上传的订单,isHaveUpLoadTicket = true");
                                        Global.isHaveUpLoadTicket = true;
                                        Global.isHaveBurdenTicket = true;
                                        LOGGER.Info("有需要同步到服务中心的订单,isHaveCenterTicket = true");
                                        Global.isHaveCenterTicket = true;
                                        trans.Complete();
                                    }
                                }
                                Thread.Sleep(100);
                            }
                          
                            LOGGER.Info("在线订单(QM)存储本地数据");
                            Task.Factory.StartNew(() =>
                            {
                                LOGGER.Info("在线订单打印");
                                this.ShowToastNotify(this, "开始打印");
                                //构建收银小票模版参数打印
                                var vars = WaiMaiHelper.BuilderQiMaiVariable(response1.Item3.Data, false);
                                Tuple<bool, string> result = WaiMaiHelper.PrinterTicket("在线订单", vars);
                                this.ShowToastNotify(this, string.Format("{0}", result.Item2));
                                //打印标签
                                LabelPrintHelper.PrintOrderLabel(orderObject);
                                //执行厨打
                                ChuDaHelper.KitchenPrinter(orderObject);
                                //执行厨打标签
                                ChuDaHelper.KitchenLabelPrinter(orderObject);
                                //执行出品
                                ChuDaHelper.MadePrinter(orderObject);
                                //通知厨显
                                UploadSCNewOrder.UploadNewOrder2SC4KDS(orderObject);
                            });

                        }
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Error(ex, "在线订单接单异常");
                    }


                    switch (SelectType)
                    {
                        case 0:
                            DoHandQuery();
                            break;
                        case 1:
                            DoQuery(1, pagerControl2.RowsPerPage);
                            break;
                    }

                }
            }
        }
        /// <summary>
        /// 订单拒单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnRefuseReceive(object sender, QiMaiOrderEventArgs e)
        {
            string orderId = e.OrderId;
            QiMaiOrderRefuseReceiveRequest request = new QiMaiOrderRefuseReceiveRequest();
            request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
            request.OrderId = orderId;
            var response = QiMaiUtils.QiMaiOrderRefuseReceive(request);
            if (response != null)
            {
                LOGGER.Info("微信订单取消:" + response.Item2);
                this.ShowToastNotify(this, response.Item2);
                if (response.Item1)
                {
                    switch (SelectType)
                    {
                        case 0:
                            DoHandQuery();
                            break;
                        case 1:
                            DoQuery(1, pagerControl2.RowsPerPage);
                            break;
                    }

                }
            }
        }
        /// <summary>
        /// 订单补单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Item_OnBuDan(object sender, QiMaiOrderEventArgs e)
        {
            if (isBudanFlag)
            {
                return;
            }
            isBudanFlag = true;
            string orderId = e.OrderId;
            OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo("7" + orderId);

            //判断订单是否存在
            if (_OrderObject == null)
            {
                try
                {
                    //接单成功打印订单
                    QiMaiOrderRequest request1 = new QiMaiOrderRequest();
                    string orderDate = this.dateInputPicker.Text;
                    request1.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                    request1.OrderId = orderId;
                    var response1 = QiMaiUtils.QiMaiOrderInfo(request1);
                    if (response1 != null && response1.Item1)
                    {
                        //组装本地数据
                        OrderObject orderObject = OtherWaiMaiApi.getOrderLocalQiMai(response1.Item3.Data);
                        logger.Info("微信订单(QM)组装完成");
                        lock (Global.Instance.SyncLock)
                        {
                            using (var db = Global.Instance.OpenDataBase)
                            {
                                using (var trans = db.GetTransaction())
                                {
                                    //整单
                                    db.Insert<OrderObject>(orderObject);

                                    foreach (OrderItem item in orderObject.Items)
                                    {
                                        ProductSpec productSpec = Global.ProductSpec._productSpecList.Find(x => x.Id.Equals(item.SpecId) && x.ProductId.Equals(item.ProductId));
                                        if (productSpec != null)
                                        {
                                            item.CostPrice = productSpec.CostPrice;
                                        }
                                        else
                                        {
                                            item.CostPrice = 0.00M;
                                        }
                                    }
                                    //单品明细
                                    db.InsertBatch<OrderItem>(orderObject.Items);
                                    //添加支付汇总的必填字段
                                    foreach (PayItem payItem in orderObject.Pays)
                                    {
                                        //档口结算信息赋默认值
                                        payItem.Ext1 = "0";
                                        payItem.Ext2 = "0";

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

                                            //zhangy 2020-02-20 Add 添加结算参数计算
                                            OrderUtils.SetPayModeDiscount(payItem, payMode);
                                        }
                                    }
                                    //支付明细
                                    db.InsertBatch<PayItem>(orderObject.Pays);
                                    //做法明细
                                    foreach (var flavor in orderObject.Items)
                                    {
                                        if (flavor.Flavors.Count > 0)
                                        {
                                            db.InsertBatch<FlavorItem>(flavor.Flavors);
                                        }
                                    }
                                    //优惠明细
                                    foreach (var promotion in orderObject.Items)
                                    {
                                        if (promotion.Promotions.Count > 0)
                                        {
                                            db.InsertBatch<PromotionItem>(promotion.Promotions);
                                        }
                                    }
                                    //如果是外卖订单,存储配送信息
                                    if (orderObject.OrderType == OrderType.微信点餐 && response1.Item3.Data.TypeCate == 3)
                                    {
                                        WxWaimaiOrder wxWaimaiOrder = new WxWaimaiOrder();
                                        wxWaimaiOrder.Id = IdWorkerUtils.Instance.NextId();
                                        wxWaimaiOrder.TenantId = orderObject.TenantId;
                                        wxWaimaiOrder.TicketNo = orderObject.TradeNo;
                                        wxWaimaiOrder.StoreId = orderObject.StoreId;
                                        wxWaimaiOrder.StoreNo = orderObject.StoreNo;
                                        wxWaimaiOrder.StoreName = orderObject.StoreName;
                                        wxWaimaiOrder.WorkerNo = orderObject.WorkerNo;
                                        wxWaimaiOrder.ShiftId = Global.Instance.BusinessPlanLog.PlanId;
                                        wxWaimaiOrder.ShiftNo = Global.Instance.BusinessPlanLog.No;
                                        wxWaimaiOrder.ReceiveName = response1.Item3.Data.AcceptName;
                                        wxWaimaiOrder.ReceiveMobile = response1.Item3.Data.AcceptMobile;
                                        wxWaimaiOrder.ReceiveAddress = response1.Item3.Data.Address;
                                        wxWaimaiOrder.DistributionFee = response1.Item3.Data.Freight;
                                        wxWaimaiOrder.Type = response1.Item3.Data.Express;
                                        if (wxWaimaiOrder.Type == 0)
                                        {
                                            wxWaimaiOrder.IsIncome = 1;
                                        }
                                        else {
                                            wxWaimaiOrder.IsIncome = 0;
                                        }
                                        wxWaimaiOrder.Status = 0;
                                        wxWaimaiOrder.CreateDate = orderObject.FinishDate;
                                        wxWaimaiOrder.CreateUser = orderObject.CreateUser;
                                        db.Insert<WxWaimaiOrder>(wxWaimaiOrder);
                                    }
                                    //8、保存耗料信息
                                    List<OrderProductBurden> orderBurdenList = new List<OrderProductBurden>();

                                    //第一步组装耗料数量
                                    foreach (var item in orderObject.Items)
                                    {
                                        //第一步先看看商品是否是管理库存的直销品
                                        var lists = Global.Product._productList;
                                        var selectProduct = new List<ProductExt>();
                                        selectProduct = lists.FindAll(x => x.Id.Equals(item.ProductId));
                                        if (selectProduct != null && selectProduct.Count > 0)
                                        {
                                            ProductExt productExt = selectProduct[0];
                                            if (productExt.StockFlag == 1)
                                            {
                                                OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                orderProductBurden.OrderId = orderObject.Id;
                                                orderProductBurden.TenantId = orderObject.TenantId;
                                                orderProductBurden.TradeNo = orderObject.TradeNo;
                                                orderProductBurden.BurdenProductId = item.ProductId;
                                                orderProductBurden.BurdenSpecId = item.SpecId;
                                                orderProductBurden.SalesUnitId = item.ProductUnitId;
                                                orderProductBurden.SalesAmount = item.Quantity - item.RefundQuantity;
                                                orderBurdenList.Add(orderProductBurden);
                                            }
                                        }
                                        //第二步获取门店耗料
                                        StringBuilder sqlBuf = new StringBuilder();
                                        sqlBuf.Append("select burdenProductId,burdenSpecId,salesUnitId,salesAmount from  pos_product_burden where productId='{0}' and specId='{1}'");
                                        string productBurdenSql = string.Format(sqlBuf.ToString(), item.ProductId, item.SpecId);
                                        List<ProductBurden> productBurdenList = db.Query<ProductBurden>(productBurdenSql).ToList();
                                        if (productBurdenList != null && productBurdenList.Count > 0)
                                        {
                                            foreach (ProductBurden productBurden in productBurdenList)
                                            {
                                                OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                orderProductBurden.OrderId = orderObject.Id;
                                                orderProductBurden.TenantId = orderObject.TenantId;
                                                orderProductBurden.TradeNo = orderObject.TradeNo;
                                                orderProductBurden.BurdenProductId = productBurden.BurdenProductId;
                                                orderProductBurden.BurdenSpecId = productBurden.BurdenSpecId;
                                                orderProductBurden.SalesUnitId = productBurden.SalesUnitId;
                                                orderProductBurden.SalesAmount = productBurden.SalesAmount * (item.Quantity - item.RefundQuantity);
                                                orderBurdenList.Add(orderProductBurden);
                                            }

                                        }
                                        //做法耗料
                                        foreach (var flavorItem in item.Flavors)
                                        {
                                            StringBuilder sqlBuf1 = new StringBuilder();
                                            sqlBuf1.Append("select burdenProductId,burdenSpecId,salesUnitId,salesAmount from  pos_make_burden where makeId='{0}'");
                                            string makeBurdenSql = string.Format(sqlBuf1.ToString(), flavorItem.MakeId);
                                            List<MakeBurden> makeBurdenList = db.Query<MakeBurden>(makeBurdenSql).ToList();
                                            if (makeBurdenList != null && makeBurdenList.Count > 0)
                                            {
                                                foreach (MakeBurden makeBurden in makeBurdenList)
                                                {
                                                    OrderProductBurden orderProductBurden = new OrderProductBurden();
                                                    orderProductBurden.OrderId = orderObject.Id;
                                                    orderProductBurden.TenantId = orderObject.TenantId;
                                                    orderProductBurden.TradeNo = orderObject.TradeNo;
                                                    orderProductBurden.BurdenProductId = makeBurden.BurdenProductId;
                                                    orderProductBurden.BurdenSpecId = makeBurden.BurdenSpecId;
                                                    orderProductBurden.SalesUnitId = makeBurden.SalesUnitId;
                                                    orderProductBurden.SalesAmount = makeBurden.SalesAmount * (flavorItem.Quantity - flavorItem.RefundQuantity);
                                                    orderBurdenList.Add(orderProductBurden);
                                                }

                                            }
                                        }
                                    }
                                    //第二部合并耗料数量
                                    if (orderBurdenList != null && orderBurdenList.Count > 0)
                                    {
                                        List<OrderProductBurden> temList = orderBurdenList.OrderBy(x => x.BurdenSpecId).ToList();
                                        Dictionary<string, Object> typeMap = new Dictionary<string, Object>();
                                        string burdenProductId_temp = "";
                                        string burdenSpecId_temp = "";
                                        string salesUnitId_temp = "";
                                        int i = 0;
                                        List<Dictionary<string, Object>> result = new List<Dictionary<string, Object>>();
                                        decimal salesAmount = 0.00M;
                                        int listLength = temList.Count;
                                        foreach (OrderProductBurden orderProductBurden in temList)
                                        {
                                            string burdenSpecId = orderProductBurden.BurdenSpecId;
                                            if (!burdenSpecId_temp.Equals(burdenSpecId))
                                            {
                                                if (i != 0)
                                                {
                                                    typeMap.Add("orderId", orderProductBurden.OrderId);
                                                    typeMap.Add("tenantId", orderProductBurden.TenantId);
                                                    typeMap.Add("tradeNo", orderProductBurden.TradeNo);
                                                    typeMap.Add("burdenProductId", burdenProductId_temp);
                                                    typeMap.Add("burdenSpecId", burdenSpecId_temp);
                                                    typeMap.Add("salesUnitId", salesUnitId_temp);
                                                    typeMap.Add("salesAmount", salesAmount);
                                                    result.Add(typeMap);
                                                    //分类改变时,清除缓存
                                                    typeMap = new Dictionary<string, Object>();
                                                }
                                                salesAmount = 0.00M;
                                                burdenProductId_temp = orderProductBurden.BurdenProductId;
                                                burdenSpecId_temp = orderProductBurden.BurdenSpecId;
                                                salesUnitId_temp = orderProductBurden.SalesUnitId;
                                            }
                                            salesAmount = salesAmount + orderProductBurden.SalesAmount;
                                            i = i + 1;
                                            if (i == listLength)
                                            {
                                                typeMap.Add("orderId", orderProductBurden.OrderId);
                                                typeMap.Add("tenantId", orderProductBurden.TenantId);
                                                typeMap.Add("tradeNo", orderProductBurden.TradeNo);
                                                typeMap.Add("burdenProductId", burdenProductId_temp);
                                                typeMap.Add("burdenSpecId", burdenSpecId_temp);
                                                typeMap.Add("salesUnitId", salesUnitId_temp);
                                                typeMap.Add("salesAmount", salesAmount);
                                                result.Add(typeMap);
                                                //分类改变时,清除缓存
                                                typeMap = new Dictionary<string, Object>();
                                            }
                                        }
                                        List<OrderProductBurden> list = new List<OrderProductBurden>();
                                        foreach (var map in result)
                                        {
                                            OrderProductBurden entity = new OrderProductBurden();
                                            entity.Id = IdWorkerUtils.Instance.NextId();
                                            entity.StoreId = orderObject.StoreId;
                                            entity.OrderId = StringUtils.GetString(map["orderId"]);
                                            entity.TenantId = StringUtils.GetString(map["tenantId"]);
                                            entity.TradeNo = StringUtils.GetString(map["tradeNo"]);
                                            entity.BurdenProductId = StringUtils.GetString(map["burdenProductId"]);
                                            entity.BurdenSpecId = StringUtils.GetString(map["burdenSpecId"]);
                                            entity.SalesUnitId = StringUtils.GetString(map["salesUnitId"]);
                                            entity.SalesAmount = StringUtils.GetDecimal(map["salesAmount"]);
                                            list.Add(entity);

                                        }
                                        db.InsertBatch<OrderProductBurden>(list);
                                    }                                    
                                    trans.Complete();
                                }
                            }

                            //更新是否有订单需要上传的状态
                            LOGGER.Info("有需要上传的订单,isHaveUpLoadTicket = true");
                            Global.isHaveUpLoadTicket = true;
                            Global.isHaveBurdenTicket = true;
                            LOGGER.Info("有需要同步到服务中心的订单,isHaveCenterTicket = true");
                            Global.isHaveCenterTicket = true;

                            Thread.Sleep(100);
                        }

                        logger.Info("微信订单(QM)入库完成");
                    }
                    this.ShowToastNotify(this, "补单成功");
                }
                catch (Exception ex)
                {
                    LOGGER.Error(ex, "微信订单(QM)补单异常");
                    this.ShowToastNotify(this, "微信订单(QM)补单异常");
                }
            }
            else
            {
                this.ShowToastNotify(this, "本地订单已存在,不用再补单");
            }
            isBudanFlag = false;
        }


        /// <summary>
        /// 获取待处理订单
        /// </summary>
        private void DoHandQuery()
        {

            if (handleQuerying)
            {
                this.ShowToastNotify(this, "查询中.....");
                return;
            }
            handleQuerying = true;
            this.tableLayoutPanel1.Controls.Clear();
            Task.Factory.StartNew(() =>
            {
                QiMaiQrderHandleRequest request = new QiMaiQrderHandleRequest();
                string orderDate = this.dateInputPicker.Text;
                request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                var response = QiMaiUtils.QiMaiQrderHandle(request);


                if (response != null && response.Item1)
                {
                    if (this.IsDisposed || !this.IsHandleCreated) return;

                    logger.Info("获取到{0}条待处理订单", response.Item3.List.Count);
                                       
                    if(response.Item3.List != null && response.Item3.List.Count > 0)
                    {
                        //有企迈小程序订单，发送界面数字角标
                        MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity()
                        {
                            Subject = Constant.MENU_TITLE_CHANGED_NOTIFY,
                            SubSubject = ModuleKeyCode.QM小程序订单.ToString(),
                            Operate = MsgEntityOperate.发布,
                            Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.QM小程序订单, MenuTileNotifyType.数量, string.Format("{0}", response.Item3.List.Count))
                        });

                        this.Invoke(new Action(() =>
                        {
                            List<QiMaiItem> detailList = new List<QiMaiItem>();
                            foreach (QiMaiOrder order in response.Item3.List)
                            {
                                var item = new QiMaiItem(order);
                                item.OnReceive += Item_OnReceive;
                                item.OnRefuseReceive += Item_OnRefuseReceive;
                                item.OnAgreereFund += Item_OnAgreereFund;
                                item.OnRefusereRund += Item_OnRefusereRund;
                                item.OnOrderPrint += Item_OnPrint;
                                item.OnOrderBuDan += Item_OnBuDan;
                                detailList.Add(item);
                            }

                            if (detailList.Count > 0)
                            {
                                this.tableLayoutPanel1.Controls.AddRange(detailList.ToArray());
                                //滚动至顶部
                                this.tableLayoutPanel1.AutoScrollPosition = new Point(0, 0);
                            }
                        }));
                    }
                    

                    //this.Invoke(new Action(() =>
                    //{
                    //    List<QiMaiItem> detailList = new List<QiMaiItem>();
                    //    foreach (QiMaiOrder order in response.Item3.List)
                    //    {
                    //        var item = new QiMaiItem(order);
                    //        item.OnReceive += Item_OnReceive;
                    //        item.OnRefuseReceive += Item_OnRefuseReceive;
                    //        item.OnAgreereFund += Item_OnAgreereFund;
                    //        item.OnRefusereRund += Item_OnRefusereRund;
                    //        item.OnOrderPrint += Item_OnPrint;
                    //        item.OnOrderBuDan += Item_OnBuDan;
                    //        detailList.Add(item);
                    //    }

                    //    if (detailList.Count > 0)
                    //    {
                    //        this.tableLayoutPanel1.Controls.AddRange(detailList.ToArray());
                    //        //滚动至顶部
                    //        this.tableLayoutPanel1.AutoScrollPosition = new Point(0, 0);
                    //    }
                    //    //更新控件
                    //    sendNewView(response.Item3.List.Count);
                    //}));
                }
                else
                {
                    this.ShowToastNotify(this, "获取小程序订单失败！");
                }

                handleQuerying = false;
            });
        }

        /// <summary>
        /// 门店营业
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnOpenStore(object sender, EventArgs e)
        {
            QiMaiShopStatusRequest request = new QiMaiShopStatusRequest();
            request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
            request.Status = "1";
            var response = QiMaiUtils.QiMaiShopStatus(request);
            if (response != null)
            {
                if (response.Item1)
                {
                    this.ShowToastNotify(this, response.Item2);
                    QueryQiMaiShopInfo();
                }
                else {
                    this.ShowToastNotify(this, response.Item2);
                }
            }
        }
        /// <summary>
        /// 门店修业
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnCloseStore(object sender, EventArgs e)
        {
            QiMaiShopStatusRequest request = new QiMaiShopStatusRequest();
            request.StoreId = Global.Instance.BusinessPlanLog.StoreId;
            request.Status = "2";
            var response = QiMaiUtils.QiMaiShopStatus(request);
            if (response != null)
            {
                if (response.Item1)
                {
                    this.ShowToastNotify(this, response.Item2);
                    QueryQiMaiShopInfo();
                }
                else
                {
                    this.ShowToastNotify(this, response.Item2);
                }
            }
        }
    }
}