using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using DevComponents.DotNetBar.Metro;
using DevComponents.DotNetBar.SuperGrid;
using DevComponents.DotNetBar.SuperGrid.Style;
using POSV.Bean;
using POSV.Business;
using POSV.Card;
using POSV.Component;
using POSV.Entity;
using POSV.Helper;
using POSV.Language;
using POSV.Member;
using POSV.MessageEvent;
using POSV.ShoppingCart;
using POSV.Utils;
using POSV.Shift;
using POSV.Report;
using System.Threading.Tasks;
using POSV.Stock;
using POSV.ServiceCenter;
using POSV.WaiMai;
using POSV.HttpApi;
using System.IO.Ports;
using DevComponents.DotNetBar.Controls;
using DevComponents.DotNetBar;
using System.Collections.ObjectModel;
using POSV.WeiXin;
using POSV.Entity.Pormotion;
using POSV.MsgCenter;
using POSV.Bill;
using POSV.StoreBusiness;
using POSV.QiMai;
using POSV.GuoPanOrder;
using System.Runtime.InteropServices;
using POSV.Proxy.GuoPan;
using POS.Language.Language;
using POSV.Dianping;

namespace POSV
{
    public partial class WeightTemplate : BaseForm
    {
        /// <summary>
        /// 计时器
        /// </summary>
        private System.Timers.Timer timer;

        //当前订单对象
        private OrderObject _orderObject = null;

        //当前选中的单品行记录
        private OrderItem _orderItem = null;

        //结账界面
        private BillFormExt _billForm = null;

        private object _promLock = new object();

        //是否正在计算促销，防止操作过快
        private bool _PromCalculateIng = false;
        public WeightTemplate()
        {
            InitializeComponent();

            this.txtSearch.Multiline = false;
            this.txtCash.Multiline = false;

            //订购界面变更通知事件
            MsgEvent.RemoveListener(Constant.CART_CHANGED_NOTIFY, this.CartChangedEventNotify);
            MsgEvent.Receive(Constant.CART_CHANGED_NOTIFY, this.CartChangedEventNotify);

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

            //练习模式切换通知
            MsgEvent.RemoveListener(Constant.STUDYMODE_CHANGED_NOTIFY, this.StudyModeChangedNotify);
            MsgEvent.Receive(Constant.STUDYMODE_CHANGED_NOTIFY, this.StudyModeChangedNotify);

            //秤状态变更
            MsgEvent.RemoveListener(Constant.CURRENTSTEELYARD_STATUS_CHANGE, this.ChangeSteelyardStatus);
            MsgEvent.Receive(Constant.CURRENTSTEELYARD_STATUS_CHANGE, this.ChangeSteelyardStatus);

            InitializeControlBox();

            InitializeGrid();

            this.txtSearch.GotFocus += this.OnInputGotFocus;

            this.categoryControl.CategoryCheckedChanged += OnCategoryCheckedChanged;

            this.historyControl.NotifyChanged += OnTelephoneHistoryControlNotifyChanged;



            lblMemberCardNo.Text = LangProxy.ToLang(lblMemberCardNo.Text);
            lblMemberAmount.Text = LangProxy.ToLang(lblMemberAmount.Text);
            lblMemberPoint.Text = LangProxy.ToLang(lblMemberPoint.Text); 
            labelX5.Text = LangProxy.ToLang(labelX5.Text);
            lblReceivableAmount.Text = LangProxy.ToLang(lblReceivableAmount.Text);
            lblOddChange.Text = LangProxy.ToLang(lblOddChange.Text);
            labelX1.Text = LangProxy.ToLang(labelX1.Text);

            foreach (var item in this.gridControl.PrimaryGrid.Columns)
            {
                var _col = item as GridColumn;
                if (_col != null)
                {
                    _col.HeaderText = LangProxy.ToLang(_col.HeaderText);
                }
            }



        }

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

            if (this.DesignMode) return;

            this.Text = LangUtils.Instance.GetString("Application.Title");

            //网络状态
            this.controlBox.NetworkStatus = Global.Instance.Online;

            //消息中心
            this.controlBox.ShowMessageCenter = Global.Instance.MessageCenterOnline.Item1;

            //加载副屏
            LoadingViceScreen();

            //登录班次
            BusinessUtils.Instance.WorkerLogin();

            //初始化收银员权限
            BusinessUtils.Instance.InitPermission();

            //刷练习模式
            StudyModeChangedNotify(this, null);

            //创建默认订单
            NewOrderObject();

            //刷新界面
            this.RefreshUi();

            //定时器
            this.timer = new System.Timers.Timer(60000);//定时周期2秒
            this.timer.Elapsed += TimerElapsed;//到60秒了做的事件
            this.timer.AutoReset = true; //是否不断重复定时器操作
            this.timer.Start();

            Task.Factory.StartNew(() =>
            {
                this.Invoke(new Action(() =>
                {
                    try
                    {
                        var lists = Global.Product._productList;
                        this.productControl1.PageNumber = 1;
                        this.productControl1.BindDataSource(lists, KeyboardAction.None);
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Error(ex, "加载商品信息异常");
                    }

                }));

            }).ContinueWith(task =>
            {
                this.Invoke(new Action(() =>
                {
                    PreLoadBillFormExt();
                }));
            }).ContinueWith(task =>
            {
                DownloadSorePrintImage.SorePrintImage();

            }).ContinueWith(task =>
            {
                this.Invoke(new Action(() =>
                {
                    LoadingTelephoneCat();
                }));

            }).ContinueWith(task =>
            {

                var cache = SaleClearUtils.Instance;

            }).ContinueWith(task =>
            {
                //更新挂单数量
                UpdateGdNum();

                //启动远程MQ连接
                // MqttClientUtils.Instance.Startup();

                Proxy.Mqtt.MqttClientUtils.Instance.Startup();

                //启动消息中心连接
                MqttUtils.Instance.Startup();

            });

            //当前未登录状态
            Global.Instance.IsLogin = true;

            //门店名称
            this.lblStoreName.Text = string.Format(LangProxy.ToLang(this.lblStoreName.Tag.ToString()), Global.Instance.Authc.TenantId, Global.Instance.Authc.StoreNo, Global.Instance.Worker.StoreInfo.Name);
            //POS编号
            this.lblPosNo.Text = string.Format(LangProxy.ToLang( this.lblPosNo.Tag.ToString()), Global.Instance.Authc.PosNo);
            //操作员工号
            this.lblWorkerNo.Text = string.Format(LangProxy.ToLang(this.lblWorkerNo.Tag.ToString()), Global.Instance.Worker.No);
            //登录日期
            this.lblLoginDate.Text = string.Format(LangProxy.ToLang(this.lblLoginDate.Tag.ToString()), Global.Instance.Worker.LastDate);
            //系统日期
            this.lblSystemDate.Text = string.Format(LangProxy.ToLang(this.lblSystemDate.Tag.ToString()), DateTime.Now.ToString("yyyy-MM-dd HH:mm"));

            //记录登录状态
            StoreBusinessUtils.SaveOperationLog("101", null);

            //打开秤
            LoadingWeight();

            InfoGuoPanDll();
        }

        /// <summary>
        /// 练习模式切换图标显示
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        protected virtual void StudyModeChangedNotify(object sender, MsgEventArgs args)
        {
            this.studyModeControl.Text = "练习模式";
            this.studyModeControl.Visible = Global.Instance.IsStudyMode();
        }

        /// <summary>
        /// 切换当前秤状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        protected virtual void ChangeSteelyardStatus(object sender, MsgEventArgs args)
        {
            try
            {
                var newStatus = args.Data.ToString();
                switch (newStatus)
                {
                    case "close":
                        {
                            //断开连接
                            this.weightShowControl1.CloseEngine();
                        }
                        break;
                    case "start":
                        {
                            //启动连接秤
                            this.weightShowControl1.StartEngine();
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "变更成状态异常");
            }
        }

        private void LoadingWeight()
        {
            try
            {
                if (this.weightShowControl1.StartEngine())
                {
                    LOGGER.Info("打开秤端口成功，开始定时读取数据");
                    //自动读取秤数据
                    //this.weightTimer = new System.Timers.Timer(200);//定时周期 1分钟5次
                    //this.weightTimer.Elapsed += WeightTimerElapsed;//到60秒了做的事件
                    //this.weightTimer.AutoReset = true; //是否不断重复定时器操作
                    //this.weightTimer.Start();

                    weightShowControl1.StabilizationEvent += StabilizationEvent;
                }
                else
                {
                    LOGGER.Debug("打开电子秤端口失败！");
                    //MessageBox.Show("");
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "打开电子秤端口异常");
            }
        }

        private void StabilizationEvent(decimal vl, bool StabilizationEvent)
        {
            lock (this)
            {
                if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEAUTOSALES, false))
                {
                    if (vl <= 0)
                    {
                        return;
                    }

                    if (this._orderObject.Items.Count > 0)
                    {
                        return;
                    }

                    if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                    {
                        this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();
                        return;
                    }

                    if (_Auto_weigh != null)
                    {
                        if ((bool)_Auto_weigh)
                        {
                            if (vl <= 0.05M)
                            {
                                _Auto_weigh = false;
                            }
                            else
                            {
                                return;
                            }
                        }
                    }

                    if (!StabilizationEvent)
                    {
                        return;
                    }

                    using (var db = Global.Instance.OpenDataBase)
                    {
                        var _datas = db.Fetch<ProductExt>(SqlConstant.ProductExtAll).Where(f => f.WeighFlag == 1);   //db.Query<ProductExt>();

                        if (_datas.Count() != 1)
                        {
                            return;
                        }

                        var _data = _datas.FirstOrDefault();

                        AddGridRow(_data, vl);
                    }
                }
            }
        }


        /// <summary>
        /// 加载来电猫
        /// </summary>
        private void LoadingTelephoneCat()
        {
            try
            {
                //来电参数
                var json = Global.Instance.GlobalConfigStringValue(ConfigConstant.DEVICE_TELEPHONE_PARAMETER, string.Empty);

                TelephoneCatParameter parameter = null;
                if (string.IsNullOrEmpty(json))
                {
                    parameter = new TelephoneCatParameter();
                }
                else
                {
                    parameter = JsonUtils.Deserialize<TelephoneCatParameter>(json);
                }

                if (parameter.Parameter == null)
                {
                    parameter.Parameter = new List<CatParameter>();
                }

                //最多两路来电
                foreach (var cat in parameter.Parameter)
                {
                    if (cat.Enable)
                    {
                        var sp = new SerialPort();
                        sp.PortName = cat.Port;
                        sp.BaudRate = cat.Baud;

                        //等待接收数据，界面互动操作
                        sp.DataReceived += (o, args) =>
                        {

                            LOGGER.Error("串口接收数据....");

                            bool isException = false;

                            int length = sp.BytesToRead;
                            byte[] data = new byte[length];
                            try
                            {
                                sp.Read(data, 0, length);
                            }
                            catch (Exception ex)
                            {
                                isException = true;
                                LOGGER.Error(ex, "串口接收数据异常");
                            }
                            finally
                            {
                                if (!isException)
                                {
                                    var recv = BitConverter.ToString(data);
                                    LOGGER.Info("Received Data<{0}>:{1} ", data.Length, recv);

                                    if (data.Length >= 8)
                                    {
                                        //报文头合法
                                        if (data[0] == 0xFF && data[1] == 0x55 && data[2] == 0xAA && data[3] == 0x00)
                                        {
                                            //包类别长度+包内容长度
                                            int len = Convert.ToInt32(data[4]);
                                            LOGGER.Debug("Content Length:{0} ", len);

                                            switch (data[5])
                                            {
                                                case 0xA0:
                                                    {
                                                        LOGGER.Info("检测到来电号码");

                                                        var array = new List<byte>();
                                                        for (int i = 8; i < length; i++)
                                                        {
                                                            byte b = data[i];
                                                            if (b == 0x0D)
                                                            {
                                                                break;
                                                            }
                                                            array.Add(b);
                                                        }

                                                        string telphone = System.Text.Encoding.ASCII.GetString(array.ToArray());

                                                        LOGGER.Info(telphone);
                                                        this.Invoke(new Action(() =>
                                                        {
                                                            this.WindowState = FormWindowState.Maximized;
                                                        }));
                                                        //通知电话外卖组件呈现到历史操作区
                                                        MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.电话外卖来电, telphone));

                                                    }
                                                    break;
                                                case 0xA1:
                                                    { LOGGER.Debug("DTMF按键和电话振铃、摘机和挂机检出数据"); }
                                                    break;
                                                case 0xA2:
                                                    { LOGGER.Debug("语音数据"); }
                                                    break;
                                                case 0xA3:
                                                    { LOGGER.Debug("系统数据"); }
                                                    break;
                                            }
                                        }
                                    }
                                }
                            }


                        };

                        sp.Open();

                        sp.RtsEnable = true;
                        sp.DtrEnable = true;

                        if (sp.IsOpen)
                        {
                            LOGGER.Info("来电参数<{0},{1},{2}>启动正常", cat.Name, cat.Port, cat.Baud);
                        }
                        else
                        {
                            LOGGER.Warn("来电参数<{0},{1},{2}>启动失败,端口不可用或被占用", cat.Name, cat.Port, cat.Baud);
                        }

                        Global.Instance.Cats.Add(sp);

                        LOGGER.Info("来电配置数量:<{0}>", Global.Instance.Cats.Count);
                    }
                    else
                    {
                        LOGGER.Warn("来电参数<{0}>尚未启用", cat.Name);
                    }
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "加载来电参数异常");
            }
            finally
            {

            }
        }

        /// <summary>
        /// 电话外送操作应答
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnTelephoneHistoryControlNotifyChanged(object sender, NotifyEventArgs e)
        {
            switch (e.KeyCode)
            {
                case "pageChange"://换页
                    {
                        var data = e.Data.ToString();
                        //购物车换页
                        if (data == "up")
                        {
                            this.gridControl.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["pgup"]);
                        }
                        else if (data == "down")
                        {
                            this.gridControl.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["pgdn"]);
                        }
                    }
                    break;
                case "waimai"://外卖
                    {
                        if (e.Data != null)
                        {
                            if (e.Data is TelephoneNotifyObject)
                            {
                                var obj = e.Data as TelephoneNotifyObject;

                                switch (e.Action)
                                {

                                    case NotifyAction.Accept:
                                        {
                                            //仅仅标识本单是电话外卖单，外送登记操作中，还是需要完善资料
                                            this._orderObject.OrderType = OrderType.电话外卖;
                                        }
                                        break;
                                    case NotifyAction.OK:
                                        {
                                            //校验是否继续
                                            var result = BusinessUtils.Instance.MenuOperateValidate(this._orderObject, this._orderItem, ModuleKeyCode.门店外卖.ToString());
                                            if (!result.Item1)
                                            {
                                                ShowToastNotify(this, result.Item2);
                                                return;
                                            }
                                            OpenDeliveryForm(obj);
                                        }
                                        break;
                                    case NotifyAction.Cancel:
                                        {
                                            this._orderObject.Delivery = null;

                                            this._orderObject.OrderType = OrderType.堂食;
                                        }
                                        break;
                                }
                            }
                        }
                    }
                    break;
                case "orderPromotion"://订单优惠
                    {
                        if (this._orderObject.OrderStatus == OrderStatus.已完成)
                        {
                            this.ShowToastNotify(this, "不支持的操作,交易已结账");
                            return;
                        }

                        if (e.Action == NotifyAction.Accept)
                        {
                            //使用优惠
                            if (e.Data is PromotionEntity)
                            {
                                bool isGo = true;

                                //3、如果有整单优惠，禁止点单操作
                                if (isGo && this._orderObject.Promotions != null && this._orderObject.Promotions.Count > 0)
                                {
                                    this.ShowToastNotify(this, "享受整单优惠，不允许继续优惠");

                                    isGo = false;
                                }
                                if (isGo)
                                {
                                    var data = e.Data as PromotionEntity;
                                    //如果需要验券,先打开验券窗口
                                    if (data.VoucherFlag == 1)
                                    {
                                        var dialogForm = new CouponCheckDialogForm(data);
                                        dialogForm.AcceptButtonClick += Form_AcceptButtonClickCouponCheck;
                                        dialogForm.ShowDialog();
                                    }
                                    else
                                    {
                                        BusinessUtils.Instance.ApplyOrderPromotion(this._orderObject, data);

                                        MsgEvent.Send(Constant.ORDERPROMOTION_CHANGED_NOTIFY, new Tuple<PromotionEntity, bool>(data, true));

                                        UpdateGrid();

                                        RefreshUiEx();
                                    }
                                }
                            }
                        }
                        else if (e.Action == NotifyAction.Cancel)
                        {
                            //取消使用的优惠
                            if (e.Data is PromotionEntity)
                            {
                                var data = e.Data as PromotionEntity;

                                PromotionUtils.Remove(_orderObject, data.PromotionId);

                                MsgEvent.Send(Constant.ORDERPROMOTION_CHANGED_NOTIFY, new Tuple<PromotionEntity, bool>(data, false));

                                UpdateGrid();

                                RefreshUiEx();
                            }
                        }
                    }
                    break;
                case "memberProm"://会员优惠
                    {
                        OnMenuMouseDown(this, new MenuEventArgs(ModuleKeyCode.代金券.ToString(), null, new ModuleMenu() { PermissionCode = "10017" }));
                    }
                    break;
                case "memberRecharge"://会员充值
                    {
                        var data = e.Data.ToString();
                        OnMenuMouseDown(this, new MenuEventArgs(ModuleKeyCode.会员卡充值.ToString(), data, new ModuleMenu() { PermissionCode = "20002" }));
                    }
                    break;
            }

        }

        private void Form_AcceptButtonClickCouponCheck(object sender, TransparentEventArgs e)
        {
            if (e.Data is Tuple<string, PromotionEntity>)
            {
                var data = e.Data as Tuple<string, PromotionEntity>;

                //输入的赠送数量
                var code = data.Item1;

                var promotionEntity = data.Item2;

                promotionEntity.CouponId = code;

                BusinessUtils.Instance.ApplyOrderPromotion(this._orderObject, promotionEntity);

                MsgEvent.Send(Constant.ORDERPROMOTION_CHANGED_NOTIFY, new Tuple<PromotionEntity, bool>(promotionEntity, true));

                UpdateGrid();

                RefreshUiEx();
            }
        }

        /// <summary>
        /// 打开外送登记界面
        /// </summary>
        /// <param name="telephone"></param>
        private void OpenDeliveryForm(TelephoneNotifyObject obj)
        {
            //电话外卖功能
            var dialogForm = new DeliveryForm(this._orderObject, obj.Telephone);
            dialogForm.AcceptButtonClick += (o, args) =>
            {
                if (args.Data != null && args.Data is OrderDelivery)
                {
                    var orderDelivery = args.Data as OrderDelivery;

                    this._orderObject.Delivery = orderDelivery;

                    this.UpdateGrid();

                    this.DeliveryPay();

                    //交易完成，关闭外卖提醒通知
                    this.historyControl.CloseWaimaiNotify();
                }
            };
            dialogForm.CancelButtonClick += (o, args) => { };

            TransparentForm trans = new TransparentForm(this, dialogForm);
            trans.Show(this);
        }

        /// <summary>
        /// 加载副屏
        /// </summary>
        private void LoadingViceScreen()
        {
            try
            {

                //Global.Instance.EnableVice = true;
                //ViceScreenForm vice2 = new ViceScreenForm();
                //vice2.Show();
                //return;
                var enableVice = Global.Instance.GlobalConfigBoolValue(ConfigConstant.DEVICE_VICE_ENABLE);
                if (enableVice)
                {
                    //启用副屏
                    Screen[] sc = Screen.AllScreens;
                    if (sc.Count() > 1)
                    {
                        ViceScreenForm vice = new ViceScreenForm();
                        vice.FormBorderStyle = FormBorderStyle.None;
                        vice.StartPosition = FormStartPosition.Manual;
                        Point p = new Point(sc[1].Bounds.Location.X, sc[1].Bounds.Location.Y);
                        vice.Location = p;
                        vice.WindowState = FormWindowState.Maximized;
                        vice.Show();
                    }
                    else
                    {
                        enableVice = false;
                        LOGGER.Info("设置启用了副屏，但是当前机器只有一块屏幕，不能启动副屏显示");
                    }
                }
                else
                {
                    LOGGER.Info("未启用副屏");
                }
                Global.Instance.EnableVice = enableVice;
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "副屏显示异常");
            }
        }

        private void PreLoadBillFormExt()
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();

            try
            {
                this._billForm = new BillFormExt();
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "预加载结账界面异常");
            }
            finally
            {
                sw.Stop();
                LOGGER.Info("预加载结账界面耗时<{0}>", sw.ElapsedMilliseconds);
            }

        }

        int monitor = 0;

        void TimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Task.Factory.StartNew(() =>
            {
                //每分钟检查一次到期时间
                StoreInfo storeInfo = Global.StoreInfo.StoreInfoMessage;
                if (storeInfo != null && storeInfo.CostMode == 0)
                {
                    int authDays = DateTimeUtils.DifferentDaysByMillisecond(storeInfo.DueDate, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                    //租赁模式剩余时间小于0天,禁止登陆系统
                    if (authDays < 0)
                    {
                        Global.Instance.AuthLogin = false;
                    }
                }
            });

            Task.Factory.StartNew(() =>
            {
                this.Invoke(new Action(() =>
                {
                    //清理内存
                    Global.ClearMemory();
                    //更新系统日期
                    this.lblSystemDate.Text = string.Format(LangProxy.ToLang( this.lblSystemDate.Tag.ToString()), DateTime.Now.ToString("yyyy-MM-dd HH:mm"));
                    //发送收银机工作状态
                    if (monitor > 4)
                    {
                        monitor = 0;
                    }
                    if (monitor == 0)
                    {
                        HttpClientUtils.PosMonitor();
                    }
                    monitor++;
                    //清理过期的沽清数据
                    SaleClearUtils.Instance.Expired();
                }));
            });
            Task.Factory.StartNew(() =>
            {
                var status = ServiceHelper.CheckServiceStatus();

                LOGGER.Debug("服务中心运行状态:" + status.ToString());

                ServiceHelper.StartService();

                //var client = MqttClientUtils.Instance;
            });
        }

        private ReaderWriterLock rwl = new ReaderWriterLock();

        /// <summary>
        /// 结账通知事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        protected virtual void OrderPaymentEventNotify(object sender, MsgEventArgs args)
        {
            if (args.Data is OrderObject)
            {
                var oldMember = this._orderObject.Member;
                var newOrderObject = args.Data as OrderObject;

                if (newOrderObject.Member != null && oldMember == null)
                {
                    //复制出来之前的gridrow
                    foreach (var item in newOrderObject.Items)
                    {
                        var oldItem = this._orderObject.Items.FirstOrDefault(x => x.Id == item.Id);
                        if (oldItem != null)
                        {
                            item.GridRow = oldItem.GridRow;
                        }
                    }

                    this._orderObject = newOrderObject;

                    this.Invoke(new Action(() =>
                    {
                        //修改会员卡号显示
                        string showCardNo = string.IsNullOrEmpty(this._orderObject.Member.CurrentCard.FaceNo) ? this._orderObject.Member.CurrentCard.CardNo : newOrderObject.Member.CurrentCard.FaceNo;

                        //会员卡号
                        this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang( this.lblMemberCardNo.Tag.ToString()), CardUtils.CardNoEncrypt(showCardNo));
                        //会员姓名
                        //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), this._orderObject.Member.Name);
                        //会员余额
                        this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), this._orderObject.Member.CurrentCard.AvailableAmount);
                        //会员积分
                        this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), this._orderObject.Member.CurrentCard.TotalPoint);

                        foreach (var item in this._orderObject.Items)
                        {
                            RefreshRow(item);
                        }
                        RefreshUiEx();
                    }));
                }
                else
                {
                    this._orderObject = newOrderObject;
                }

                this.Invoke(new Action(() =>
                {
                    if (this._orderObject.ChangeAmount > 0)
                    {
                        this.lblOddChange.Text = string.Format(this.lblOddChange.Tag.ToString(), this._orderObject.ChangeAmount);
                    }

                    var result = BusinessUtils.Instance.OrderFinished(_orderObject);
                    if (result.Item1)
                    {
                        this.DestoryOrderObject(false);
                    }
                    else
                    {
                        ShowToastNotify(this, result.Item2);
                    }
                }));
            }

            //var bmp = ScreenCapturePInvoke.CaptureFullScreen(true);

            //var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"data\desktop.jpg");

            //bmp.Save(path, ImageFormat.Jpeg);

            //bmp.Dispose();

            //Rectangle bounds = Screen.GetBounds(Point.Empty);
            //using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
            //{
            //    using (Graphics g = Graphics.FromImage(bitmap))
            //    {
            //        g.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
            //    }
            //    rwl.AcquireWriterLock(Timeout.Infinite);
            //    bitmap.Save(AppDomain.CurrentDomain.BaseDirectory + @"data\ScreenTask.jpg", ImageFormat.Jpeg);
            //    rwl.ReleaseWriterLock();

            //}
        }

        private void OnCategoryCheckedChanged(object sender, Component.CategoryEventArgs e)
        {
            //zhangy 2020-03-14 Add 重写以下代码，解决茶饮版全部分类显示的Bug
            var productType = e.Data;
            try
            {
                var lists = Global.Product._productList;
                var selectProduct = new List<ProductExt>();
                if (!Constant.ALL_PRODUCT_TAG.Equals(productType.No))
                {
                    selectProduct = lists.FindAll(x => !string.IsNullOrEmpty(x.TypePath) && x.TypePath.StartsWith(productType.Path));
                }
                else
                {
                    selectProduct = lists;
                }
                this.productControl1.PageNumber = 1;
                this.productControl1.BindDataSource(selectProduct, KeyboardAction.None);
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "加载商品信息异常");
            }

            //zhangy 2020-03-14 Edit 注释以下代码 
            //var productType = e.Data;

            //try
            //{
            //    var lists = Global.Product._productList;
            //    var selectProduct = new List<ProductExt>();
            //    if (!Constant.ALL_PRODUCT_TAG.Equals(productType.No))
            //    {
            //        selectProduct = lists.FindAll(x => !string.IsNullOrEmpty(x.TypePath) && x.TypePath.StartsWith(productType.Path));
            //    }
            //    this.productControl1.PageNumber = 1;
            //    this.productControl1.BindDataSource(selectProduct, KeyboardAction.None);
            //}
            //catch (Exception ex)
            //{
            //    LOGGER.Error(ex, "加载商品信息异常");
            //}

        }

        protected void CartChangedEventNotify(object sender, MsgEventArgs args)
        {
            this.Invoke(new Action(() =>
            {
                if (args.Data is ShoppingCartItem)
                {
                    var data = args.Data as ShoppingCartItem;

                    Global.Instance.ReloadConfig(ConfigConstant.CART_GROUP);

                    this.RefreshGrid(data);

                    //刷新品类显示
                    var category_json_template = Global.Instance.GlobalConfigStringValue(ConfigConstant.CATEGORY_JSON_TEMPLATE);
                    if (string.IsNullOrEmpty(category_json_template))
                    {
                        category_json_template = JsonUtils.Serialize(new CategoryItem());
                    }
                    MsgEvent.Send(Constant.CATEGORY_CHANGED_NOTIFY, JsonUtils.Deserialize<CategoryItem>(category_json_template));

                    //刷新品项显示
                    var productJsonTemplate = Global.Instance.GlobalConfigStringValue(ConfigConstant.PRODUCT_JSON_TEMPLATE);
                    if (string.IsNullOrEmpty(productJsonTemplate))
                    {
                        productJsonTemplate = JsonUtils.Serialize(new ProductItem());
                    }
                    MsgEvent.Send(Constant.PRODUCT_CHANGED_NOTIFY, JsonUtils.Deserialize<ProductItem>(productJsonTemplate));

                    //刷新主菜单
                    var modules = new List<ModuleMenu>();
                    lock (Global.Instance.SyncLock)
                    {
                        using (var db = Global.Instance.OpenDataBase)
                        {
                            modules = db.Query<ModuleMenu>().ToList();
                        }
                    }

                    MsgEvent.Send(Constant.MENU_CHANGED_NOTIFY, modules);
                }
            }));
        }

        private void InitializeGrid()
        {
            try
            {
                gridControl.GetDetailRowHeight -= GridControlRowGetDetailHeight;
                gridControl.GetDetailRowHeight += GridControlRowGetDetailHeight;

                gridControl.PostRenderRow -= GridControlPostRenderRow;
                gridControl.PostRenderRow += GridControlPostRenderRow;

                gridControl.RowActivated -= GridControlRowActivated;
                gridControl.RowActivated += GridControlRowActivated;

                gridControl.CellClick -= GridControlCellClick;
                gridControl.CellClick += GridControlCellClick;

                var cart_json_template = Global.Instance.GlobalConfigStringValue(ConfigConstant.CART_JSON_TEMPLATE);
                if (string.IsNullOrEmpty(cart_json_template))
                {
                    cart_json_template = JsonUtils.Serialize(new ShoppingCartItem());
                }

                this.RefreshGrid(JsonUtils.Deserialize<ShoppingCartItem>(cart_json_template));

            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "初始化购物车界面异常");
            }
            finally
            {
                this.leftContainer.Invalidate();
            }
        }

        /// <summary>
        /// 点击点单列表中任意单元格事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GridControlCellClick(object sender, GridCellClickEventArgs e)
        {
            if (e.MouseEventArgs.Button == MouseButtons.Left)
            {
                OrderItem orderItem = e.GridCell.GridRow.Tag as OrderItem;
                //设置当前活跃行
                this._orderItem = orderItem;
            }
        }


        public void RefreshGrid(ShoppingCartItem item)
        {
            //变更前的数据库存储
            var rows = item.Rows;
            //总宽度，重新设置左侧宽
            long totalWidth = rows.Where(x => (x.Display)).Sum(m => (m.Width));

            GridPanel panel = gridControl.PrimaryGrid;

            StringBuilder footer = new StringBuilder();

            foreach (CartRow row in rows)
            {
                var col = panel.Columns[row.Name];

                col.HeaderStyles.Default.Font = this.GetSystemFont(item.TitleFont);
                col.HeaderStyles.Default.Alignment = Alignment.MiddleCenter;
                col.HeaderStyles.Default.Background.Color1 = ColorTranslator.FromHtml(item.TitleColor);
                col.HeaderStyles.Default.Background.Color2 = ColorTranslator.FromHtml(item.TitleColor);

                col.HeaderStyles.Default.TextColor = ColorTranslator.FromHtml(item.TextColor);

                col.MinimumWidth = Convert.ToInt32(row.Width);
                col.Width = Convert.ToInt32(row.Width);
                col.FillWeight = Convert.ToInt32(row.Width);


                col.Visible = row.Display;
                col.HeaderText = string.IsNullOrEmpty(row.Alias) ? row.Text : row.Alias;

                if (col.Visible)
                {
                    switch (row.Name.ToLower())
                    {
                        case "name":
                            {
                                footer.AppendFormat("<span align=\"left\" width=\"{0}\"><font size=\"+2\"><b>" + LangProxy.ToLang("合计:") + "</b></font></span>", row.Width - 2);
                            }
                            break;
                        case "quantity":
                            {
                                footer.AppendFormat("<span align=\"center\" width=\"{0}\"><font size=\"+2\"><b>#" + LangProxy.ToLang("数量") + "#</b></font></span>", row.Width - 2);
                            }
                            break;
                        case "amount":
                            {
                                footer.AppendFormat("<span align=\"center\" width=\"{0}\"><font size=\"+2\"><b>#" + LangProxy.ToLang("金额") + "#</b></font></span>", row.Width - 2);
                            }
                            break;
                        case "discount":
                            {
                                footer.AppendFormat("<span align=\"center\" width=\"{0}\"><font size=\"+2\"><b>#" + LangProxy.ToLang("优惠") + "#</b></font></span>", row.Width - 2);
                            }
                            break;
                        default:
                            {
                                footer.AppendFormat("<span align=\"center\" width=\"{0}\"></span>", row.Width - 2);
                            }
                            break;
                    }
                }
            }


            //行最小高度
            panel.MinRowHeight = item.RowHeight;
            panel.DefaultRowHeight = 0;

            panel.Footer.RowHeight = item.RowHeight;
            panel.DefaultVisualStyles.FooterStyles.Default.Font = this.GetSystemFont(item.TitleFont);
            panel.DefaultVisualStyles.FooterStyles.Default.Alignment = Alignment.MiddleLeft;
            panel.Footer.Tag = footer.ToString();

            panel.InitialSelection = RelativeSelection.None;
            panel.InitialActiveRow = RelativeRow.None;

            //滚动条
            this.gridControl.Width = Convert.ToInt32(totalWidth);
            this.gridControl.HScrollBarVisible = false;
            this.gridControl.VScrollBarVisible = true;
            this.gridControl.VScrollBar.Width = 0;

            this.leftContainer.Width = Convert.ToInt32(totalWidth);
            this.leftContainer.Invalidate();
        }

        /// <summary>
        /// 网络连接状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        protected override void NetworkEventNotify(object sender, MsgEventArgs args)
        {
            base.NetworkEventNotify(sender, args);

            if (IsDisposed || !this.IsHandleCreated) return;

            //呈现联机更新状态
            this.BeginInvoke(new MethodInvoker(() =>
            {
                this.controlBox.NetworkStatus = Global.Instance.Online;

                //是否显示消息中心状态
                this.controlBox.ShowMessageCenter = Global.Instance.MessageCenterOnline.Item1;
                this.controlBox.MessageCenterStatus = Global.Instance.MessageCenterOnline.Item2;

            }));
        }

        /// <summary>
        ///  创建一个订单对象，本单交易完成前，对象唯一存在
        /// </summary>
        /// <returns></returns>
        private OrderObject NewOrderObject()
        {

            if (this._orderObject == null)
            {
                this._orderObject = BusinessUtils.Instance.NewOrderObject();

                //异步单号
                //Task.Factory.StartNew(() => {
                //    return OrderUtils.Instance.GenerateTicketNoEx(); 
                //}).ContinueWith(task => {
                //    this._orderObject.TradeNo = task.Result.Item3;
                //});

                //订单商品明细               
                var observableCollection = new ObservableCollection<OrderItem>();
                observableCollection.CollectionChanged += OrderItemCollectionChanged;

                this._orderObject.Maps = observableCollection;

                //会员卡号、姓名
                this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), string.Empty);
                //会员姓名
                //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), string.Empty);
                //会员余额
                this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), string.Empty);
                //会员积分
                this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), string.Empty);

                //刷新桌号
                MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.桌号.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.桌号, MenuTileNotifyType.数量, _orderObject.TableName) });

                //默认营业模式
                bool ts = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ORDERTYPEDEFAULTTS, true);
                if (ts)
                {
                    this._orderObject.OrderType = OrderType.堂食;
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.堂食.ToString()) });
                }
                else
                {
                    this._orderObject.OrderType = OrderType.外带;
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.外带.ToString()) });
                }
            }

            this._orderItem = null;

            return this._orderObject;
        }

        private void OrderItemCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            //Console.WriteLine("Action for this event: {0}", e.Action);

            switch (e.Action)
            {
                case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                    {

                    }
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                    {

                    }
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
                    {

                    }
                    break;
            }

            GridPanel panel = gridControl.PrimaryGrid;
            int i = 0;

            foreach (var item in this._orderObject.Maps)
            {
                GridRow row = (GridRow)panel.Rows[i];

                item.OrderNo = (++i);

                //修改行序号
                row["order"].Value = item.OrderNo;

            }
            //刷新界面元素
            //this.RefreshUi();
        }

        /// <summary>
        /// （曾拓）自动称重的结账流程优化，上一张小票结账完成后检测称上的重量变换，需要先检测到称的重量已经归零（5g以内），然后重新稳定重量之后才生成新的点餐记录
        /// </summary>
        private bool? _Auto_weigh = null;
        private OrderObject DestoryOrderObject(bool forced, bool newOrder = true)
        {
            //关闭会员优惠提醒
            MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, 0));

            //禁止交易完成后立即清除单据信息，显示已结账
            bool allowShowPreOrder = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_SHOW_PREORDER);

            _Auto_weigh = true;

            if (forced || !allowShowPreOrder)
            {
                //清理GridPanel
                GridPanel panel = this.gridControl.PrimaryGrid;
                panel.Rows.Clear();

                this.checkoutControl.Visible = false;
                this.txtCash.Text = "0";

                this._orderObject = null;

                //清理搜索框条件
                this.txtSearch.Text = string.Empty;
                this.txtSearch.Focus();

                //通知副屏
                if (Global.Instance.EnableVice)
                {
                    MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.CLEARALLITEMS, null));
                }
                if (newOrder)
                {
                    return NewOrderObject();
                }
                else
                {
                    return null;
                }
            }
            else
            {
                this.checkoutControl.Visible = true;

                //重置会员信息，默认情况下，支付完成后支持刷卡
                this._orderObject.Member = null;

                //清理搜索框条件
                this.txtSearch.Text = string.Empty;
                this.txtSearch.Focus();

                //通知副屏
                if (Global.Instance.EnableVice)
                {
                    MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.FINISHEDORDER, null));
                }

                return this._orderObject;
            }
        }

        /// <summary>
        /// 刷新点单列表，更新界面元素
        /// </summary>
        private void RefreshUi()
        {
            this.Invoke(new Action(() =>
            {
                RefreshUiEx();
            }));
            Task.Factory.StartNew(() =>
            {
                _PromCalculateIng = true;
                try
                {
                    lock (this._promLock)
                    {
                        this.CalPromotion();
                    }
                }
                catch (Exception ex)
                {
                    LOGGER.Error(ex, "计算优惠发生异常");
                    Global.Instance.BugReport(ex, "计算优惠发生异常");
                }
            }).ContinueWith(task =>
            {
                _PromCalculateIng = false;
            });
        }

        private void RefreshUiEx()
        {
            GridPanel panel = gridControl.PrimaryGrid;
            string footer = panel.Footer.Tag.ToString();

            string text = footer.ToString();
            text = text.Replace("#" + LangProxy.ToLang("数量") + "#", this._orderObject.TotalQuantity.ToString());

            //列表是否显示折后价
            bool showDiscountPrice = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_SHOW_DISCOUNTPRICE, false);
            if (showDiscountPrice)
            {
                text = text.Replace("#" + LangProxy.ToLang("金额") + "#", (this._orderObject.Amount - this._orderObject.DiscountAmount).ToString());
            }
            else
            {
                text = text.Replace("#" + LangProxy.ToLang("金额") + "#", this._orderObject.Amount.ToString());
            }

            text = text.Replace("#" + LangProxy.ToLang("优惠") + "#", this._orderObject.DiscountAmount.ToString());

            panel.Footer.Text = text;


            //计算抹零金额
            decimal malingAmount = OrderUtils.MalingAmount(this._orderObject.ReceivableAmount, null);

            //应收金额
            this.lblReceivableAmount.Text = string.Format(LangProxy.ToLang( this.lblReceivableAmount.Tag.ToString()), this._orderObject.ReceivableAmount.ToString());

            //现金输入框,考虑抹零金额的因素
            this.txtCash.Text = (this._orderObject.ReceivableAmount - malingAmount).ToString();
            this.txtCash.SelectAll();
            //客显
            try
            {
                GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Total, this._orderObject.ReceivableAmount.ToString("f2"));
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "客显异常");
            }
        }

        private void CalPromotion()
        {
            //套餐，自动找到套餐主菜进行优惠计算
            if (this._orderItem != null && this._orderItem.RowState == OrderRowState.套餐明)
            {
                //套餐明细，找到套餐主菜进行优惠计算
                var mainItem = this._orderObject.Items.Find(x => x.Group == this._orderItem.Group && x.RowState == OrderRowState.套餐主);
                if (mainItem != null)
                {
                    CalItemPromEngine(mainItem);
                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(this._orderObject, mainItem);
                }
            }
            else
            {
                CalItemPromEngine(this._orderItem);
            }

            CalOrderPromEngine();
        }

        private void CalItemPromEngine(OrderItem item)
        {
            //先计算当前单品优惠，取最优
            if (item != null)
            {
                if (item.Promotions != null && item.Promotions.Count > 0)
                {
                    //有优惠，不计算单品优惠
                    return;
                }
                var promResult = PromotionEngine.Instance.CalItemPromotion(this._orderObject, item);
                if (promResult.Count > 0)
                {
                    if (promResult.Exists(x => x.Type == PromotionType.双数特价优惠 || x.Type == PromotionType.双数特价赠送))
                    {
                        ApplyDoublePromMain(promResult, item);
                    }
                    else
                    {
                        var fineProm = promResult.OrderByDescending(x => x.DiscountAmount).ToList()[0];
                        var needUpdate = BusinessUtils.Instance.ApplyItemFinePromotion(this._orderObject, item, fineProm);
                        if (needUpdate)
                        {
                            this.Invoke(new Action(() =>
                            {
                                RefreshRow(item);
                                RefreshUiEx();
                            }));
                        }
                    }
                }
            }
        }

        #region 双数特价
        /// <summary>
        /// 双数特价优惠入口
        /// </summary>
        /// <param name="promResult"></param>
        /// <param name="item"></param>
        private void ApplyDoublePromMain(List<PromotionEntity> promResult, OrderItem item)
        {
            var fineProm = promResult.FirstOrDefault(x => x.Type == PromotionType.双数特价优惠 || x.Type == PromotionType.双数特价赠送);
            //优先处理双数促销
            if (fineProm.Type == PromotionType.双数特价赠送)
            {
                ApplyDoublePromGive(fineProm, item);
            }
            else if (fineProm.Type == PromotionType.双数特价优惠)
            {
                ApplyDoublePromDiscount(fineProm, item);
            }
        }

        /// <summary>
        /// 双数特价优惠处理
        /// </summary>
        /// <param name="fineProm"></param>
        /// <param name="item"></param>
        private void ApplyDoublePromDiscount(PromotionEntity fineProm, OrderItem item)
        {
            //优惠商品
            var product = fineProm.Products[0];
            //满足双数特价的主商品数量
            var masterList = this._orderObject.Items.FindAll(x => x.SpecId == product.SpecId && x.Promotions.Count == 0 && string.IsNullOrEmpty(x.ParentId));
            //已参与满足双数特价的子商品数量
            var subList = this._orderObject.Items.FindAll(x => x.SpecId == product.SpecId && x.Promotions.Count == 1
                                                            && x.Promotions[0].PromotionType == PromotionType.双数特价优惠
                                                            && x.Promotions[0].PlanNo == fineProm.PromotionId);
            //主商品数量
            var totalMasterQuantity = masterList.Sum(x => x.Quantity);
            //子商品数量
            var totalSubQuantity = subList.Sum(x => x.Quantity);
            //应优惠商品数量
            var shouldQuantity = product.Quantity;

            if (shouldQuantity > totalSubQuantity)
            {
                //新增优惠商品
                var dQuantity = (shouldQuantity - totalSubQuantity);
                bool isSucc = false;
                //假如是子商品
                if (item.Quantity == dQuantity)
                {
                    isSucc = DoublePromPart3(item, masterList, subList, dQuantity, fineProm);
                }
                if (!isSucc)
                {
                    //假如是主商品
                    isSucc = DoublePromPart2(item, masterList, subList, dQuantity, fineProm);
                    if (!isSucc)
                    {
                        //主商品需要拆行
                        if (item.Quantity > dQuantity)
                        {
                            item.Quantity -= dQuantity;
                            //套餐主数量变更，同步更新子商品数量
                            UpdateSuitSubQuantity(item);
                            //沽清
                            //创建新的OrderItem
                            var newItem = BusinessUtils.Instance.NewOrderItem(_orderObject, ObjectUtils.Copy(item.ProductExt));
                            newItem.Quantity = dQuantity;
                            newItem.ParentId = item.Id;
                            //新Item加入促销
                            BusinessUtils.Instance.ApplyPromotionEntity(this._orderObject, newItem, fineProm);
                            //新数据定位
                            int orderNo = BusinessUtils.Instance.AppendItemPosition(this._orderObject, item);
                            this.Invoke(new Action(() =>
                            {
                                AddGridRowExt(newItem.ProductExt, newItem, orderNo);
                                RefreshRow(item);
                                RefreshUiEx();
                            }));
                        }
                        else
                        {
                            LOGGER.Error("未能成功处理双数特价优惠的UI商品调整");
                        }
                    }
                }
            }
            else if (shouldQuantity < totalSubQuantity)
            {
                //减少商品
                var specs = _orderObject.Items.FindAll(x => x.SpecId == product.SpecId);
                if (specs.Count > 1)
                {
                    var quantity = (totalSubQuantity - shouldQuantity);
                    List<OrderItem> updateItems = new List<OrderItem>();
                    List<OrderItem> deleteItems = new List<OrderItem>();
                    foreach (var sub in subList)
                    {
                        if (quantity > 0)
                        {
                            if (sub.ParentId == item.Id)
                            {
                                if (sub.Quantity > quantity)
                                {
                                    sub.Quantity -= quantity;
                                    quantity = 0;
                                    updateItems.Add(sub);
                                    break;
                                }
                                else if (sub.Quantity <= quantity)
                                {
                                    quantity -= sub.Quantity;
                                    deleteItems.Add(sub);
                                }
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (quantity > 0)
                    {
                        //计算异常
                        this.ShowToastNotify(this, "双数促销执行错误，请消单后重新点单！");
                    }

                    foreach (var del in deleteItems)
                    {
                        this.Invoke(new Action(() =>
                        {
                            DoRemoveOrderItem(del);
                        }));
                    }

                    foreach (var up in updateItems)
                    {
                        //更新促销
                        RefreshPromotionEntityItem(up, fineProm);
                    }
                }
            }
        }

        /// <summary>
        /// 双数特价赠送处理
        /// </summary>
        /// <param name="fineProm"></param>
        /// <param name="item"></param>
        private void ApplyDoublePromGive(PromotionEntity fineProm, OrderItem item)
        {
            var p = fineProm.Products[0];
            //已赠送商品集
            var giveItems = _orderObject.Items.FindAll(x => x.SpecId == p.SpecId && x.Promotions.Count == 1
                                                        && x.Promotions[0].PromotionType == PromotionType.双数特价赠送
                                                        && x.Promotions[0].PlanNo == fineProm.PromotionId);
            //已赠送商品总数
            var giveQuantity = giveItems.Sum(x => x.Quantity);
            //差值
            var dQuantity = p.Quantity - giveQuantity;

            if (dQuantity > 0)
            {
                var childItem = _orderObject.Items.FirstOrDefault(x => x.SpecId == p.SpecId && x.ParentId == item.Id && x.Promotions.Count == 1 && x.Promotions[0].PromotionType == PromotionType.双数特价赠送 && x.Promotions[0].PlanNo == fineProm.PromotionId);
                if (childItem != null)
                {
                    //已经存在双数特价赠送的商品，直接将赠送的商品数量置为当前商品数量，适用于操作数量增加
                    childItem.Quantity += dQuantity;

                    RefreshPromotionEntityItem(childItem, fineProm);
                }
                else
                {
                    //新增一行商品
                    //沽清
                    //创建新的OrderItem
                    var newItem = BusinessUtils.Instance.NewOrderItem(_orderObject, ObjectUtils.Copy(item.ProductExt));
                    newItem.Quantity = dQuantity;
                    //新Item加入促销
                    newItem.ParentId = item.Id;
                    BusinessUtils.Instance.ApplyPromotionEntity(this._orderObject, newItem, fineProm);

                    var orderNo = BusinessUtils.Instance.AppendItemPosition(this._orderObject, item);
                    this.Invoke(new Action(() =>
                    {
                        AddGridRowExt(newItem.ProductExt, newItem, orderNo);
                    }));
                }
            }
            else if (dQuantity < 0)
            {
                //减少赠送
                decimal delQuantity = dQuantity * -1;
                if (delQuantity > 0)
                {
                    var childItem = this._orderObject.Items.FirstOrDefault(x => x.ParentId == item.Id && x.RowState != OrderRowState.套餐明);
                    if (childItem.Quantity > delQuantity)
                    {
                        childItem.Quantity -= delQuantity;
                        RefreshPromotionEntityItem(childItem, fineProm);
                    }
                }
            }
        }

        /// <summary>
        /// 双数特价，判定当前商品为主商品，寻找子商品
        /// </summary>
        /// <param name="masterItem"></param>
        /// <param name="masterList"></param>
        /// <param name="subList"></param>
        /// <param name="dQuantity"></param>
        /// <param name="fineProm"></param>
        /// <returns></returns>
        private bool DoublePromPart2(OrderItem masterItem, List<OrderItem> masterList, List<OrderItem> subList, decimal dQuantity, PromotionEntity fineProm)
        {
            bool result = false;

            var currItemSub = subList.FindAll(x => x.ParentId == masterItem.Id);

            //当前主菜对应的子菜数量，判断是否饱和，饱和找其他主
            var currItemQuantity = currItemSub.Sum(x => x.Quantity);
            if (currItemSub.Count > 0 && (currItemQuantity + dQuantity) < masterItem.Quantity)
            {
                //不饱和，可以接受
                var tempItem = currItemSub[0];

                tempItem.Quantity += dQuantity;
                masterItem.Quantity -= dQuantity;

                //套餐主数量变更，同步更新子商品数量
                UpdateSuitSubQuantity(masterItem);

                RefreshPromotionEntityItem(tempItem, fineProm);

                this.Invoke(new Action(() =>
                {
                    RefreshRow(masterItem);
                    RefreshRow(tempItem);
                    RefreshUiEx();
                }));

                result = true;
            }
            else
            {
                //查找正好符合数量的未被使用的商品作为子商品
                var subItem = masterList.FirstOrDefault(x => x.Id != masterItem.Id && x.Quantity == dQuantity && (!_orderObject.Items.Exists(y => y.ParentId == x.Id) || (x.RowState == OrderRowState.套餐主 && !_orderObject.Items.Exists(y => y.ParentId == x.Id && y.RowState != OrderRowState.套餐明))));
                if (subItem != null)
                {
                    //应用优惠
                    BusinessUtils.Instance.ApplyPromotionEntity(this._orderObject, subItem, fineProm);

                    subItem.ParentId = masterItem.Id;
                    BusinessUtils.Instance.ApplyPromotionEntity(this._orderObject, subItem, fineProm);

                    //移动至主商品下方
                    int orderNo = BusinessUtils.Instance.AppendItemPosition(this._orderObject, masterItem);
                    MoveItemPosition(subItem, orderNo);

                    this.Invoke(new Action(() =>
                    {
                        RefreshRow(subItem);
                        RefreshUiEx();
                    }));
                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 双数特价，判断当前商品为子商品，寻找主商品
        /// </summary>
        /// <param name="item"></param>
        /// <param name="masterList"></param>
        /// <param name="subList"></param>
        /// <param name="dQuantity"></param>
        /// <param name="fineProm"></param>
        /// <returns></returns>
        private bool DoublePromPart3(OrderItem item, List<OrderItem> masterList, List<OrderItem> subList, decimal dQuantity, PromotionEntity fineProm)
        {
            bool result = false;

            //查找正好符合数量的未被使用的商品作为主商品
            //符合数量有两种，1、一个主商品下已有子商品，但是该主商品还可以接纳当前数量的商品
            OrderItem masterItem = null;
            foreach (var tmp in masterList)
            {
                if (tmp.Id != item.Id)
                {
                    if (tmp.RowState == OrderRowState.普通)
                    {
                        var currItemSub = subList.FindAll(x => x.ParentId == tmp.Id);
                        var currItemQuantity = currItemSub.Sum(x => x.Quantity);
                        if (tmp.Quantity - currItemQuantity >= dQuantity)
                        {
                            masterItem = tmp;
                            break;
                        }
                    }
                    else if (tmp.RowState == OrderRowState.套餐主)
                    {
                        var currItemSub = subList.FindAll(x => x.ParentId == tmp.Id && x.RowState == OrderRowState.套餐主);
                        var currItemQuantity = currItemSub.Sum(x => x.Quantity);
                        if (tmp.Quantity - currItemQuantity >= dQuantity)
                        {
                            masterItem = tmp;
                            break;
                        }
                    }
                }
            }
            if (masterItem != null)
            {
                //应用优惠
                item.ParentId = masterItem.Id;
                BusinessUtils.Instance.ApplyPromotionEntity(this._orderObject, item, fineProm);
                //移动至主商品下方
                int orderNo = BusinessUtils.Instance.AppendItemPosition(this._orderObject, masterItem);
                MoveItemPosition(item, orderNo);

                this.Invoke(new Action(() =>
                {
                    RefreshRow(item);
                    RefreshUiEx();
                }));
                result = true;
            }
            return result;
        }

        #endregion

        /// <summary>
        /// 更新促销信息
        /// </summary>
        /// <param name="item"></param>
        /// <param name="fineProm"></param>
        private void RefreshPromotionEntityItem(OrderItem item, PromotionEntity fineProm)
        {
            var p = fineProm.Products[0];
            var promotion = item.Promotions[0];
            //优惠金额
            promotion.DiscountAmount = OrderUtils.ToRound(fineProm.DiscountAmount / p.Quantity * item.Quantity);
            //折扣率
            if (item.Amount != 0)
            {
                promotion.DiscountRate = OrderUtils.ToRound((item.Amount - promotion.DiscountAmount) / item.Amount);
            }
            else
            {
                promotion.DiscountRate = 0;
            }

            PromotionUtils.Calculate(this._orderObject, item, promotion);

            if (item.RowState == OrderRowState.套餐主)
            {
                //同步更改套餐明细数量
                UpdateSuitSubQuantity(item);
            }
            else
            {
                this.Invoke(new Action(() =>
                {
                    RefreshRow(item);
                }));
            }

            this.Invoke(new Action(() =>
            {
                RefreshUiEx();
            }));
        }



        private void MoveItemPosition(OrderItem item, int orderNo)
        {
            if (item.RowState == OrderRowState.普通)
            {
                //移动到父商品下方
                this._orderObject.Maps.Move(item.OrderNo - 1, orderNo);
                this.Invoke(new Action(() =>
                {
                    this.gridControl.PrimaryGrid.Rows.Remove(item.GridRow);
                    this.gridControl.PrimaryGrid.Rows.Insert(orderNo, item.GridRow);
                }));
            }
            else if (item.RowState == OrderRowState.套餐主)
            {
                //套餐整体移动到父商品下方
                this._orderObject.Maps.Move(item.OrderNo - 1, orderNo);
                this.Invoke(new Action(() =>
                {
                    this.gridControl.PrimaryGrid.Rows.Remove(item.GridRow);
                    this.gridControl.PrimaryGrid.Rows.Insert(orderNo, item.GridRow);
                }));
                var subItems = this._orderObject.Items.FindAll(x => x.RowState == OrderRowState.套餐明 && x.ParentId == item.Id);
                foreach (var sub in subItems)
                {
                    var targetCount = ++orderNo;
                    this._orderObject.Maps.Move(sub.OrderNo - 1, targetCount);
                    this.Invoke(new Action(() =>
                    {
                        this.gridControl.PrimaryGrid.Rows.Remove(sub.GridRow);
                        this.gridControl.PrimaryGrid.Rows.Insert(targetCount, sub.GridRow);
                    }));
                }
            }
        }



        /// <summary>
        /// 套餐主数量变更，同步更新子商品数量变更
        /// </summary>
        /// <param name="item"></param>
        private void UpdateSuitSubQuantity(OrderItem item)
        {
            if (item.RowState == OrderRowState.套餐主)
            {
                var details = this._orderObject.Items.FindAll(x => x.ParentId == item.Id && x.Group == item.Group);
                foreach (var detail in details)
                {
                    //道菜加价金额
                    detail.SuitAmount = item.Quantity * detail.SuitAddPrice;

                    //道菜数量随主菜变化而增加
                    detail.Quantity = item.Quantity * detail.SuitQuantity;

                    //将更改后的行数据同步到订单列表
                    var inx = this._orderObject.Maps.IndexOf(detail);
                    this._orderObject.Maps[inx] = detail;

                    this.Invoke(new Action(() =>
                    {
                        RefreshRow(detail);
                    }));
                }

                //套餐道菜分摊
                PromotionUtils.CalculateSuitShare(this._orderObject, item);

                //套餐主特殊处理
                this.Invoke(new Action(() =>
                {
                    UpdateSuitMain(item);
                }));
            }
        }

        private void CalOrderPromEngine()
        {
            //计算整单优惠
            var orderPromResult = PromotionEngine.Instance.CalOrderPromotion(this._orderObject);
            this.Invoke(new Action(() =>
            {
                MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.优惠列表, orderPromResult));
            }));
        }



        private void InitializeControlBox()
        {
            //注册关闭事件
            this.controlBox.CloseClick -= OnControlBoxCloseClick;
            this.controlBox.CloseClick += OnControlBoxCloseClick;
            //注册最小化事件
            this.controlBox.MinimizedClick -= OnControlBoxMinimizedClick;
            this.controlBox.MinimizedClick += OnControlBoxMinimizedClick;
            //注册设置事件
            this.controlBox.SettingsClick -= OnControlBoxSettingsClick;
            this.controlBox.SettingsClick += OnControlBoxSettingsClick;

            this.controlBox.ShowLockScreen = true;
            //操作锁屏事件
            this.controlBox.LockedClick -= OnControlBoxLockedClick;
            this.controlBox.LockedClick += OnControlBoxLockedClick;
            //二维码
            this.controlBox.ShowQrCode = true;
            this.controlBox.QRCodeClick -= OnControlBoxQrCodeClick;
            this.controlBox.QRCodeClick += OnControlBoxQrCodeClick;

        }

        private void OnControlBoxQrCodeClick(object sender, EventArgs e)
        {
            AuthQRForm qr = new AuthQRForm();
            qr.ShowDialog();
        }

        private void OnControlBoxMinimizedClick(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }

        private void OnControlBoxCloseClick(object sender, EventArgs e)
        {
            LOGGER.Info("手动退出系统");

            StoreBusinessUtils.SaveOperationLog("102", null);

            this.Close();
        }


        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            bool isSuccess = false;

            bool isGo = true;
            //允许有未结账单据(含挂单)存在时退出系统
            if (!Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ACCOUNT_EN_ROUTE, false) && this._orderObject != null && this._orderObject.OrderStatus == OrderStatus.新建单 && this._orderObject.Items.Count > 0)
            {
                var dialog = new DialogForm("操作提醒", "有正在操作的单据,不允许退出系统", MessageBoxIcon.Warning, MessageBoxButtons.OK);
                dialog.ShowDialog();
                isGo = false;

                isSuccess = true;
            }

            if (isGo && !Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ACCOUNT_EN_ROUTE_NOTIFY, false))
            {
                var dialog = new DialogForm("操作提醒", "您确定是要退出系统吗?", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);
                if (DialogResult.OK != dialog.ShowDialog())
                {
                    isSuccess = true;
                }
                else
                {
                    isSuccess = false;
                }
            }

            e.Cancel = isSuccess;
        }

        protected override void OnFormClosed(FormClosedEventArgs e)
        {
            //关闭秤端口
            this.weightShowControl1.CloseEngine();

            base.OnFormClosed(e);
        }

        private void OnControlBoxLockedClick(object sender, EventArgs e)
        {
            var locked = new LockForm();

            locked.ShowDialog();
        }


        private void OnControlBoxSettingsClick(object sender, EventArgs e)
        {
            string permissionCode = "40001";

            bool isGo = true;

            if (isGo)
            {
                //有权限
                if (Global.Instance.HasPermission(permissionCode))
                {
                    var trans = new TransparentForm(this, new SettingsForm());
                    trans.Show();
                }
                else
                {
                    var authForm = new AuthDialogForm("参数设置", permissionCode, this._orderObject);
                    authForm.ExpectValidate(permissionCode);

                    authForm.AcceptButtonClick += (o, args) =>
                    {

                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                        {
                            var _trans = new TransparentForm(this, new SettingsForm());
                            _trans.Show();
                        }
                    };

                    authForm.CancelButtonClick += (o, args) => { };
                    TransparentForm trans = new TransparentForm(this, authForm);
                    trans.Show(this);
                }
            }
        }

        private void OnProductCheckedChanged(object sender, Component.ProductEventArgs e)
        {
            //添加点单过快提示
            if (_PromCalculateIng)
            {
                this.ShowToastNotify(this, "操作过快，请重新操作");
                return;
            }

            bool isGo = true;

            //1、先判断是否已经完成
            if ((this._orderObject.OrderType == OrderType.电话外卖 && this._orderObject.OrderStatus == OrderStatus.等待付款) || this._orderObject.OrderStatus == OrderStatus.已完成)
            {
                this.DestoryOrderObject(true);

                isGo = true;
            }

            //2、判断订单号是否正常
            if (isGo && string.IsNullOrEmpty(this._orderObject.TradeNo))
            {
                //尝试重新获取一次单号
                var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                if (ticket.Item1)
                {
                    this._orderObject.TradeNo = ticket.Item3;
                }

                //重新判断是否获取到单号
                if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                {
                    //是否提醒收银员
                    var isNofity = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_TICKET_NO_NOFITY, true);
                    //是否采用本机单号
                    var isLocalTicketNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_LOCAL_TICKET_NO, false);

                    string notifyMessage = "获取全局单号失败,收银参数禁止使用本机单号,请重新操作";
                    if (isNofity)
                    {
                        DialogForm dialog = null;
                        //采用本机单号
                        if (isLocalTicketNo)
                        {
                            notifyMessage = "获取全局单号失败,采用本机单号可能出现重复,是否继续?";
                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                        }
                        else
                        {
                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.OK);
                        }
                        //操作员选择了 是
                        if (DialogResult.Yes == dialog.ShowDialog())
                        {
                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                            isGo = true;
                        }
                        else
                        {
                            isGo = false;
                        }
                    }
                    else
                    {
                        if (isLocalTicketNo)
                        {
                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                            isGo = true;
                        }
                        else
                        {
                            isGo = false;

                            this.ShowToastNotify(this, "获取全局单号失败,设置禁止使用本机单号,请重试");
                        }
                    }

                }
                else
                {
                    isGo = true;
                }
            }

            //3、如果有整单优惠，禁止点单操作
            if (isGo && this._orderObject.Promotions != null && this._orderObject.Promotions.Count > 0)
            {
                this.ShowToastNotify(this, "享受整单优惠，不允许继续点单");

                isGo = false;
            }

            //4、允许销售售价为零的商品
            var allowPriceZero = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ALLOW_PRICE_ZERO, false);
            if (isGo && e.Product.Price <= 0 && !allowPriceZero)
            {
                this.ShowToastNotify(this, "不允许售卖价格为零的商品");

                isGo = false;
            }

            //5、售价为零的商品时提示
            var priceZeroNotify = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_PRICE_ZERO_NOTIFY, false);
            if (isGo && e.Product.Price <= 0 && priceZeroNotify)
            {
                var dialog = new DialogForm("提示信息", "您是否要售卖零售价的单品", MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                //操作员选择了 是
                if (DialogResult.Yes == dialog.ShowDialog())
                {
                    isGo = true;
                }
                else
                {
                    isGo = false;
                }
            }


            //**********************开始点单*******************************
            var product = e.Product;

            if (isGo)
            {
                var newProduct = ObjectUtils.Copy<ProductExt>(product);
                AddGridRow(newProduct);
            }

        }

        public void AddGridRow(ProductExt product, decimal quantity = 0)
        {
            //添加沽清业务规则
            SaleClear saleClear = null;
            if (SaleClearUtils.Instance.Maps.ContainsKey(product.Id))
            {
                saleClear = SaleClearUtils.Instance.Maps[product.Id];
            }
            //是否参与沽清
            bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

            if (isSaleClear && saleClear.Quantity <= 0)
            {
                this.ShowToastNotify(this, "已经销售完了!");

                return;
            }

            //创建新的OrderItem
            var master = BusinessUtils.Instance.NewOrderItem(this._orderObject, product);

            if (quantity != 0)
            {
                master.Quantity = quantity;
            }
            //多规格选择
            if (product.SpecCount > 1)
            {
                //规格权限控制码 10007
                string permissionCode = "10007";

                bool isGo = true;

                //是否启用授权窗口
                var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);

                //没有按钮权限
                if (isGo && !isAuthz)
                {
                    this.ShowToastNotify(this, "您没有多规格选择权限!");
                    isGo = false;
                }

                if (isGo)
                {
                    var autoSelectSpec = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_AUTO_SELECT_SPEC, true);
                    //有规格操作权限
                    if (Global.Instance.HasPermission(permissionCode))
                    {
                        if (autoSelectSpec)
                        {
                            SelectSpecDialog(master, product, permissionCode, saleClear);
                        }
                        else
                        {
                            AddGridRow(product, master, saleClear);
                        }
                    }
                    else
                    {
                        var authForm = new AuthDialogForm("规格", permissionCode, this._orderObject);
                        authForm.ExpectValidate(permissionCode);

                        authForm.AcceptButtonClick += (o, args) =>
                        {

                            if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                            {
                                if (autoSelectSpec)
                                {
                                    this.SelectSpecDialog(master, product, permissionCode, saleClear);
                                }
                                else
                                {
                                    AddGridRow(product, master, saleClear);
                                }
                            }
                        };

                        authForm.CancelButtonClick += (o, args) => { };
                        TransparentForm trans = new TransparentForm(this, authForm);
                        trans.Show(this);
                    }
                }
            }
            else
            {
                AddGridRow(product, master, saleClear, quantity == 0);
            }
        }

        private void SelectSpecDialog(OrderItem master, ProductExt product, string permissionCode, SaleClear saleClear = null)
        {
            var dialogForm = new SpecDialogForm(master, permissionCode);
            dialogForm.AcceptButtonClick += (sender, args) =>
            {
                AddGridRow(product, master, saleClear);
            };

            dialogForm.CancelButtonClick += (sender, args) => { };

            TransparentForm trans = new TransparentForm(this, 0.01, dialogForm);
            trans.Show(this);
        }

        private void SelectProductCouponDialog()
        {
            var dialogForm = new ProductCouponForm(this._orderItem);
            dialogForm.AcceptButtonClick += (sender, args) =>
            {
                var storeProductCoupon = args.Data as StoreProductCoupon;
                //this.ShowToastNotify(this, storeProductCoupon.EndDate);
                //使用以后增加优惠券促销
                var fineProm = new PromotionEntity();
                fineProm.PromotionId = storeProductCoupon.TicketId;
                fineProm.PromotionDesc = storeProductCoupon.Description;
                fineProm.CouponId = storeProductCoupon.Id;
                fineProm.DiscountAmount = storeProductCoupon.CouponPrice;
                fineProm.IsOrder = false;
                fineProm.Type = PromotionType.商品优惠券;
                var needUpdate = BusinessUtils.Instance.ApplyItemFinePromotion(this._orderObject, this._orderItem, fineProm);
                if (needUpdate)
                {
                    this.Invoke(new Action(() =>
                    {
                        RefreshRow(this._orderItem);
                        RefreshUiEx();
                    }));
                }
            };

            dialogForm.CancelButtonClick += (sender, args) => { };
            TransparentForm trans = new TransparentForm(this, 0.01, dialogForm);
            trans.Show(this);
        }

        private void AddGridRow(ProductExt product, OrderItem master, SaleClear saleClear = null, bool weighaffirm = true)
        {
            //判断是否需要输入售价
            var priceZeroInput = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_PRICE_ZERO_INPUT, false);
            if (priceZeroInput && product.Price <= 0)
            {
                var dialogForm = new InputPriceDialogForm(product);
                dialogForm.AcceptButtonClick += (o, args) =>
                {
                    var inputValue = Convert.ToDecimal(args.Data);

                    product.Price = inputValue;
                    product.MemberPrice = inputValue;
                    product.OtherPrice = inputValue;


                    //售价
                    master.SalePrice = product.Price;
                    //单品最低售价
                    master.MinPrice = product.MinPrice;
                    //会员价
                    master.MemberPrice = product.MemberPrice;
                    //批发价
                    master.DispatchPrice = product.DispatchPrice;
                    //第三方价
                    master.OtherPrice = product.OtherPrice;

                    //默认情况下，零售价和售价一样，零售价主要解决前台售价为0的商品，需要录入的售价
                    master.Price = product.Price;
                    //默认情况下，折后单价和零售价一样
                    master.DiscountPrice = master.Price;


                    AddGridRowWeightDeal(product, master, saleClear);
                };

                dialogForm.CancelButtonClick += (o, args) => { };

                TransparentForm trans = new TransparentForm(this, 0.01, dialogForm);
                trans.Show(this);
            }
            else
            {
                AddGridRowWeightDeal(product, master, saleClear, weighaffirm);
            }
        }

        private void AddGridRowWeightDeal(ProductExt product, OrderItem master, SaleClear saleClear = null, bool weighaffirm = true)
        {
            if (master.ProductExt.WeighFlag == 1 && weighaffirm)
            {
                //开启先点商品模式
                bool wieghtModeProduct = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_WIEGHTMODEPRODUCT, false);
                if (wieghtModeProduct)
                {
                    var form = new WeightDishShowForm(this.weightShowControl1, product, master);
                    form.WeightOKClick += OnWeightOKClick;
                    TransparentForm trans = new TransparentForm(this, form);
                    trans.Show(this);
                }
                else
                {
                    //称重商品，判断秤是否稳定，数量是否合法
                    var status = this.weightShowControl1.Status;
                    switch (status)
                    {
                        case WeightStatusEnum.异常:
                            {
                                //弹出输入数量
                                //数量权限控制码 10003
                                string permissionCode = "10003";

                                bool isGo = true;

                                //是否启用授权窗口
                                var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);

                                //没有按钮权限
                                if (isGo && !isAuthz)
                                {
                                    this.ShowToastNotify(this, "您没有修改数量权限!");
                                    isGo = false;
                                }

                                if (isGo)
                                {
                                    //有数量操作权限
                                    if (Global.Instance.HasPermission(permissionCode))
                                    {
                                        InputQuantity(product, master, saleClear);
                                    }
                                    else
                                    {
                                        var authForm = new AuthDialogForm("数量", permissionCode, this._orderObject);
                                        authForm.ExpectValidate(permissionCode);

                                        authForm.AcceptButtonClick += (o, args) =>
                                        {

                                            if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                            {
                                                this.InputQuantity(product, master, saleClear);
                                            }
                                        };

                                        authForm.CancelButtonClick += (o, args) => { };
                                        TransparentForm trans = new TransparentForm(this, authForm);
                                        trans.Show(this);
                                    }
                                }
                            }
                            break;
                        case WeightStatusEnum.稳定:
                            {
                                var weight = this.weightShowControl1.Weight;
                                if (weight <= 0)
                                {
                                    this.ShowToastNotify(this, "失败:重量必须大于零，请检查");
                                    return;
                                }

                                master.Quantity = weight;

                                AddGridRowEx(product, master, true, null);
                            }
                            break;
                        default:
                            {
                                this.ShowToastNotify(this, string.Format("失败:{0}，请检查", status.ToString()));
                                return;
                            }
                    }
                }
            }
            else
            {
                AddGridRowEx(product, master, true, saleClear);
            }
        }

        private void OnWeightOKClick(object sender, NotifyEventArgs e)
        {
            Tuple<ProductExt, OrderItem, decimal> data = e.Data as Tuple<ProductExt, OrderItem, decimal>;
            var product = data.Item1;
            var master = data.Item2;
            var weight = data.Item3;
            if (weight <= 0)
            {
                this.ShowToastNotify(this, "失败:重量必须大于零，请检查");
                return;
            }
            master.Quantity = weight;
            AddGridRowEx(product, master, true, null);
        }

        private void InputQuantity(ProductExt product, OrderItem master, SaleClear saleClear = null)
        {
            var target = new QuantityForm(master, "10003");
            target.CancelButtonClick += (o, args) => { };
            target.AcceptButtonClick += (o, args) =>
            {
                AddGridRowEx(product, master, true, null);
            };
            TransparentForm trans = new TransparentForm(this, target);
            trans.Show(this);
        }

        private void AddGridRowEx(ProductExt product, OrderItem master, bool refUI, SaleClear saleClear = null)
        {
            bool isException = false;
            try
            {


                List<OrderItem> rows = BusinessUtils.Instance.BuildGridRow(_orderObject, product, master);

                foreach (var item in rows)
                {
                    if (string.IsNullOrEmpty(item.ProductId))
                    {
                        isException = true;
                        DialogForm errDialog = new DialogForm("错误提示", "套餐中的商品当前门店不存在，请联系管理员！", MessageBoxIcon.Error, MessageBoxButtons.OK);
                        errDialog.ShowDialog();
                        return;
                    }
                }

                GridPanel panel = gridControl.PrimaryGrid;

                foreach (var r in rows)
                {
                    GridRow gridRow = null;

                    switch (r.RowState)
                    {
                        case OrderRowState.套餐明:
                            {
                                //套餐明细不显示售价和优惠
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, /*r.Price*/"", r.SuitAddPrice > 0 ? ("+" + r.SuitAddPrice) : "", /*r.Discount*/"", r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                        default:
                            {
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, r.Price, r.Amount, r.Discount, r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                    }

                    gridRow.RowHeight = 0;
                    gridRow.Tag = r;

                    //将RowIndex映射
                    r.GridRow = gridRow;


                    panel.Rows.Add(gridRow);
                    panel.SetSelected(gridRow, true);
                    panel.SetActiveRow(gridRow);

                    //压入集合对象
                    this._orderObject.Maps.Add(r);


                    //通知副屏
                    if (Global.Instance.EnableVice)
                    {
                        var rowVice = new GridRow(r.DisplayName, r.Quantity, r.SalePrice, r.Amount, r.FlavorNames);
                        rowVice.Tag = r;
                        MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.ADDORDERITEM, rowVice));
                    }


                }
                if (refUI)
                {
                    this.RefreshUi();
                }

                Application.DoEvents();
                int h = panel.Rows.Sum(p => p.Size.Height);
                this.gridControl.VScrollOffset = h;
            }
            catch (Exception ex)
            {
                isException = true;

                LOGGER.Error(ex, "单品加入购物车异常");
            }
            finally
            {
                if (!isException)
                {
                    var isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                    //沽清处理
                    if (isSaleClear)
                    {
                        saleClear.SaleQuantity += 1;

                        SaleClearUtils.Instance.Maps[product.Id] = saleClear;
                    }

                    //清理搜索框条件
                    this.txtSearch.Text = string.Empty;
                    this.txtSearch.Focus();

                    //套餐自动打开换菜窗口
                    if (product.SuitFlag == 1)
                    {
                        var showRes = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ADDSUITAUTOOPENCHANGEFORM, false);
                        if (showRes)
                        {
                            OnShortcutMouseDown(null, new MenuEventArgs("换菜", null, new ModuleMenu() { PermissionCode = "10008" }));
                        }
                    }
                }
            }
        }

        private void AddGridRowExt(ProductExt product, OrderItem master, int row, SaleClear saleClear = null)
        {
            bool isException = false;
            try
            {
                List<OrderItem> rows = BusinessUtils.Instance.BuildGridRow(_orderObject, product, master);

                foreach (var item in rows)
                {
                    if (string.IsNullOrEmpty(item.ProductId))
                    {
                        isException = true;
                        DialogForm errDialog = new DialogForm("错误提示", "套餐中的商品当前门店不存在，请联系管理员！", MessageBoxIcon.Error, MessageBoxButtons.OK);
                        errDialog.ShowDialog();
                        return;
                    }
                }

                GridPanel panel = gridControl.PrimaryGrid;

                foreach (var r in rows)
                {
                    GridRow gridRow = null;

                    switch (r.RowState)
                    {
                        case OrderRowState.套餐明:
                            {
                                //套餐明细不显示售价和优惠
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, /*r.Price*/"", r.SuitAddPrice > 0 ? ("+" + r.SuitAddPrice) : "", /*r.Discount*/"", r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                        default:
                            {
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, r.Price, r.Amount, r.Discount, r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                    }

                    gridRow.RowHeight = 0;
                    gridRow.Tag = r;

                    //将RowIndex映射
                    r.GridRow = gridRow;

                    panel.Rows.Insert(row, gridRow);
                    panel.SetSelected(gridRow, true);
                    panel.SetActiveRow(gridRow);

                    //压入集合对象
                    this._orderObject.Maps.Insert(row, r);
                    //套餐一次增加多行，++处理
                    row++;

                    //通知副屏
                    if (Global.Instance.EnableVice)
                    {
                        var rowVice = new GridRow(r.DisplayName, r.Quantity, r.SalePrice, r.Amount, r.FlavorNames);
                        rowVice.Tag = r;
                        MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.ADDORDERITEM, rowVice));
                    }

                }
                this.RefreshUi();

                Application.DoEvents();
                int h = panel.Rows.Sum(p => p.Size.Height);
                this.gridControl.VScrollOffset = h;
            }
            catch (Exception ex)
            {
                isException = true;

                LOGGER.Error(ex, "单品加入购物车异常");
            }
            finally
            {
                if (!isException)
                {
                    var isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                    //沽清处理
                    if (isSaleClear)
                    {
                        saleClear.SaleQuantity += 1;

                        SaleClearUtils.Instance.Maps[product.Id] = saleClear;
                    }

                    //清理搜索框条件
                    this.txtSearch.Text = string.Empty;
                    this.txtSearch.Focus();

                    //套餐自动打开换菜窗口
                    //if (product.SuitFlag == 1)
                    //{
                    //    var showRes = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ADDSUITAUTOOPENCHANGEFORM, false);
                    //    if (showRes)
                    //    {
                    //        OnShortcutMouseDown(null, new MenuEventArgs("换菜", null, new ModuleMenu() { PermissionCode = "10008" }));
                    //    }
                    //}
                }
            }
        }

        private void ShowAllOrderItem(OrderObject order)
        {
            bool isException = false;
            try
            {
                List<OrderItem> rows = order.Items;

                GridPanel panel = gridControl.PrimaryGrid;

                foreach (var r in rows)
                {
                    GridRow gridRow = null;

                    switch (r.RowState)
                    {
                        case OrderRowState.套餐明:
                            {
                                //套餐明细不显示售价和优惠
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, /*r.Price*/"", r.SuitAddPrice > 0 ? ("+" + r.SuitAddPrice) : "", /*r.Discount*/"", r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                        default:
                            {
                                gridRow = new GridRow(r.OrderNo, r.DisplayName, r.Quantity, r.ProductUnitName, r.Price, r.Amount, r.Discount, r.Underline, r.Flavor, r.Group, r.ParentId, r.Scheme);
                            }
                            break;
                    }

                    gridRow.RowHeight = 0;
                    gridRow.Tag = r;

                    //将RowIndex映射
                    r.GridRow = gridRow;


                    panel.Rows.Add(gridRow);
                    panel.SetSelected(gridRow, true);
                    panel.SetActiveRow(gridRow);
                }

                Application.DoEvents();
                int h = panel.Rows.Sum(p => p.Size.Height);
                this.gridControl.VScrollOffset = h;
            }
            catch (Exception ex)
            {
                isException = true;

                LOGGER.Error(ex, "展示购物车所有商品异常");
            }
            finally
            {
                if (!isException)
                {
                    //清理搜索框条件
                    this.txtSearch.Text = string.Empty;
                    this.txtSearch.Focus();
                }
            }
        }

        /// <summary>
        /// 更新购物车列表当前活跃行
        /// </summary>
        private void UpdateGridRow()
        {
            this.Invoke(new Action(() =>
            {
                if (this._orderItem == null) return;

                RefreshRow(this._orderItem);
            }));
        }

        private void RefreshRow(OrderItem orderItem)
        {
            GridRow row = orderItem.GridRow;

            //删除订单项时，判空
            if (row == null || row["name"] == null)
            {
                return;
            }

            //商品名称显示规格
            string _productName = orderItem.DisplayName;
            decimal _quantity = orderItem.Quantity;
            string _unit = orderItem.ProductUnitName;

            //列表是否显示折后价
            bool showDiscountPrice = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_SHOW_DISCOUNTPRICE, false);
            decimal _salePrice = orderItem.Price;
            if (showDiscountPrice)
            {
                _salePrice = orderItem.DiscountPrice;
            }

            decimal _amount = orderItem.Amount;
            if (showDiscountPrice)
            {
                _amount = orderItem.Amount - orderItem.TotalDiscountAmount;
            }

            decimal _promotion = orderItem.TotalDiscountAmount;

            row["name"].Value = _productName;
            row["quantity"].Value = _quantity;
            row["price"].Value = OrderUtils.ToRound(_salePrice);
            row["unit"].Value = _unit;
            row["amount"].Value = OrderUtils.ToRound(_amount);

            row["discount"].Value = _promotion;

            this._orderItem.Discount = _promotion;

            if (orderItem.RowState == OrderRowState.套餐明)
            {
                row["quantity"].Value = orderItem.Quantity;
                row["price"].Value = "";
                row["amount"].Value = orderItem.SuitAmount > 0 ? ("+" + orderItem.SuitAmount) : "";
                row["discount"].Value = "";

                this._orderItem.Discount = 0;
            }

            if (orderItem.Flavors.Count() > 0)
            {
                row["flavor"].Value = 1;
            }
            else
            {
                row["flavor"].Value = 0;
            }

            row.InvalidateRender();

            row.InvalidateLayout();

            //通知副屏
            if (Global.Instance.EnableVice)
            {
                MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.UPDATEORDERITEM, orderItem));
            }
        }

        /// <summary>
        /// 更新套餐主信息
        /// </summary>
        /// <param name="item"></param>
        private void UpdateSuitMain(OrderItem item)
        {
            if (item.RowState == OrderRowState.套餐主 || item.RowState == OrderRowState.套餐明)
            {
                var mainItem = this._orderObject.Items.Find(x => x.Group == item.Group && x.RowState == OrderRowState.套餐主);
                var subItems = this._orderObject.Items.FindAll(x => x.Group == item.Group && x.RowState == OrderRowState.套餐明);
                if (mainItem != null && subItems != null)
                {
                    mainItem.FlavorCount = subItems.Sum(x => x.FlavorCount);
                    mainItem.FlavorAmount = subItems.Sum(x => x.FlavorAmount);
                    mainItem.FlavorDiscountAmount = subItems.Sum(x => x.FlavorDiscountAmount);
                    mainItem.FlavorReceivableAmount = subItems.Sum(x => x.FlavorReceivableAmount);
                    //刷新购物车
                    this.RefreshRow(mainItem);
                }
            }
        }

        /// <summary>
        /// 刷新整个点单列表
        /// </summary>
        private void UpdateGrid()
        {
            this.Invoke(new Action(() =>
            {
                foreach (var item in this._orderObject.Items)
                {
                    RefreshRow(item);
                }
            }));
        }

        /// <summary>
        /// 刷新点单列表指定行
        /// </summary>
        /// <param name="item"></param>
        private void UpdateGridRow(OrderItem item)
        {
            this.Invoke(new Action(() =>
            {
                GridPanel panel = gridControl.PrimaryGrid;
                panel.SetSelected(panel.ActiveRow, false);
                panel.SetSelected(item.GridRow, true);
                panel.SetActiveRow(item.GridRow);

                //设置当前活跃行
                this._orderItem = item;
                //刷新购物车
                this.RefreshRow(this._orderItem);
            }));
        }


        void GridControlRowGetDetailHeight(object sender, GridGetDetailRowHeightEventArgs e)
        {
            GridRow row = e.GridRow;
            if (row != null)
            {
                OrderItem item = row.Tag as OrderItem;

                int isFlavor = (int)row["flavor"].Value;

                if (isFlavor == 1)
                {
                    string text = item.FlavorNames;

                    Rectangle r = row.FirstVisibleCell.ContentBounds;
                    Rectangle t = row.LastVisibleCell.ContentBounds;

                    Size rsize = e.SizeNeeded;
                    rsize.Height = 0;
                    rsize.Width = (t.Right - r.Left);

                    var sf = TextFormatFlags.Left | TextFormatFlags.NoPadding | TextFormatFlags.WordBreak;
                    Size size = TextRenderer.MeasureText(text, Constant.DEFAULT_FONT, rsize, sf);

                    e.PostDetailHeight = size.Height;
                }
            }
        }

        void GridControlPostRenderRow(object sender, GridPostRenderRowEventArgs e)
        {
            GridRow row = e.GridRow as GridRow;
            if (row != null)
            {
                OrderItem item = row.Tag as OrderItem;

                //是否下划线
                int isUnderline = (int)row["underline"].Value;
                //是否包含口味
                int isFlavor = (int)row["flavor"].Value;

                Rectangle r = row.FirstVisibleCell.ContentBounds;
                Rectangle t = row.LastVisibleCell.ContentBounds;

                string text = item.FlavorNames;


                r.Width = t.Right - r.X;// - Dpi.Width5;
                r.Y = e.Bounds.Bottom - row.EffectivePostDetailRowHeight;// - Dpi.Height5;
                r.Height = row.EffectivePostDetailRowHeight;

                if (isFlavor == 1)
                {
                    //e.Graphics.FillRectangle(Brushes.LightPink , r);
                    //e.Graphics.DrawRectangle(Pens.RosyBrown , r);

                    r.Inflate(-2, 1);

                    var sf = TextFormatFlags.Left | TextFormatFlags.NoPadding | TextFormatFlags.WordBreak;

                    TextRenderer.DrawText(e.Graphics, text, Constant.DEFAULT_FONT, r,
                                      row.IsSelected ? Color.DimGray : Color.DimGray, sf);
                }

                //绘制下边线
                if (isUnderline == 1)
                {
                    System.Drawing.Pen pen1 = new System.Drawing.Pen(System.Drawing.Color.DarkGray);//画笔
                    e.Graphics.DrawLine(pen1, new Point(r.Left, t.Bottom + row.EffectivePostDetailRowHeight), new Point(t.Right, t.Bottom + row.EffectivePostDetailRowHeight));
                    pen1.Dispose();
                }

                //绘制右边线
                System.Drawing.Pen pen = new System.Drawing.Pen(SystemColors.ControlDark);//画笔
                e.Graphics.DrawLine(pen, new Point(t.Right, t.Top - 1), new Point(t.Right, row.EffectivePostDetailRowHeight + t.Bottom));
                pen.Dispose();
            }
        }

        private void GridControlRowActivated(object sender, GridRowActivatedEventArgs e)
        {
            if (e.NewActiveRow != null)
            {
                GridPanel panel = e.GridPanel;
                panel.SetSelected(e.OldActiveRow, false);
                panel.SetSelected(e.NewActiveRow, true);
                panel.SetActiveRow(e.NewActiveRow);

                //当前行的对象
                OrderItem orderItem = e.NewActiveRow.Tag as OrderItem;

                //设置当前活跃行
                this._orderItem = orderItem;

                //显示在称重控件上
                this.weightShowControl1.SetGoodsInfo(_orderItem.DisplayName, _orderItem.Price, _orderItem.Amount);

                //通知副屏，选中指定行
                if (Global.Instance.EnableVice)
                {
                    MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.UPDATEORDERITEM, orderItem));
                }
            }
        }

        private void OnShortcutMouseDown(object sender, Component.MenuEventArgs e)
        {
            var result = BusinessUtils.Instance.MenuOperateValidate(this._orderObject, this._orderItem, e.KeyCode);
            if (!result.Item1)
            {
                ShowToastNotify(this, result.Item2);
                return;
            }

            MenuAction(e.Target, e.Index, e.KeyCode, e.KeyData, e.PermissionCode);
        }

        /// <summary>
        /// 删除指定订单项
        /// </summary>
        /// <param name="item"></param>
        private void DoRemoveOrderItem(OrderItem item)
        {
            if (item != null)
            {
                GridPanel panel = gridControl.PrimaryGrid;
                List<OrderItem> rows = new List<OrderItem>();
                rows.Add(item);
                //依赖
                var subRows = this._orderObject.Items.FindAll(x => x.ParentId == item.Id);
                rows.AddRange(subRows);
                //买一送一套餐时，需要将送的套餐明细同步删除
                foreach (var subRow in subRows)
                {
                    if (subRow.RowState == OrderRowState.套餐主)
                    {
                        var subsubRows = this._orderObject.Items.FindAll(x => x.ParentId == subRow.Id);
                        rows.AddRange(subsubRows);
                    }
                }
                var activeRow = panel.ActiveRow;
                if (rows.Count > 0)
                {
                    foreach (var row in rows)
                    {
                        if (row.GridRow != null)
                        {
                            //删除一条记录前 获取当前记录的下一个可用行记录
                            activeRow = row.GridRow.NextVisibleRow;
                            if (activeRow == null)
                            {
                                activeRow = row.GridRow.PrevVisibleRow;
                            }

                            //删除当前行
                            panel.Rows.Remove(row.GridRow);

                            //移除数据存储                           
                            this._orderObject.Maps.Remove(row);


                            //通知副屏
                            if (Global.Instance.EnableVice)
                            {
                                MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.DELETESINGLEITEM, row.GridRow.RowIndex));
                            }

                        }

                        Thread.Sleep(5);
                    }
                }

                //选择当前活动行
                panel.SetSelected(activeRow, true);
                panel.SetActiveRow(activeRow);
                this.RefreshUi();
            }
        }

        /// <summary>
        /// 删除单品
        /// </summary>
        private void RemoveOrderItem()
        {

            bool isSuccess = true;

            OrderItem item = null;
            try
            {
                GridPanel panel = gridControl.PrimaryGrid;
                if (panel.ActiveRow != null)
                {
                    item = panel.ActiveRow.Tag as OrderItem;

                    if (item.RowState == OrderRowState.套餐明)
                    {
                        isSuccess = false;

                        this.ShowToastNotify(this, "请选择套餐删除!");

                        return;
                    }

                    DoRemoveOrderItem(item);
                }
            }
            finally
            {
                if (isSuccess && item != null)
                {
                    //添加沽清业务规则
                    SaleClear saleClear = null;
                    if (SaleClearUtils.Instance.Maps.ContainsKey(item.ProductId))
                    {
                        saleClear = SaleClearUtils.Instance.Maps[item.ProductId];
                    }
                    //是否参与沽清
                    bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                    if (isSaleClear)
                    {
                        saleClear.SaleQuantity -= item.Quantity;

                        SaleClearUtils.Instance.Maps[item.ProductId] = saleClear;
                    }
                    StoreBusinessUtils.SaveOperationLog("203", "商品:" + item.ProductNo + item.Name);
                }
            }
        }

        /// <summary>
        /// 取消全单
        /// </summary>
        private void CleanOrderObject()
        {
            bool isSuccess = true;
            //消单是否提醒
            if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ORDER_CANCEL_NOTIFY))
            {
                DialogForm dialog = new DialogForm("操作提醒", "您确定是要进行取消全单操作吗?", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);
                if (DialogResult.OK != dialog.ShowDialog())
                {
                    isSuccess = false;
                }
            }

            if (isSuccess)
            {
                StoreBusinessUtils.SaveOperationLog("201", "单号:" + _orderObject.TradeNo);

                //处理参与沽清的业务
                var rows = this._orderObject.Items;
                if (rows.Count > 0)
                {
                    foreach (var row in rows)
                    {
                        //套餐明细不处理沽清业务
                        if (row.RowState == OrderRowState.套餐明)
                        {
                            continue;
                        }

                        //添加沽清业务规则
                        SaleClear saleClear = null;
                        if (SaleClearUtils.Instance.Maps.ContainsKey(row.ProductId))
                        {
                            saleClear = SaleClearUtils.Instance.Maps[row.ProductId];
                        }
                        //是否参与沽清
                        bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                        if (isSaleClear)
                        {
                            saleClear.SaleQuantity -= row.Quantity;

                            SaleClearUtils.Instance.Maps[row.ProductId] = saleClear;
                        }
                    }
                }


                //发送消单操作,清理表格数据
                GridPanel panel = gridControl.PrimaryGrid;
                panel.Rows.Clear();

                //消单后,清理订单对象
                DestoryOrderObject(true);

                //刷新界面
                this.RefreshUi();
            }
        }

        private void OrderItemQuantity(object sender, string permissionCode, AuthOperator auth = AuthOperator.输入操作, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            try
            {
                var button = sender as MetroTileItem;
                //修改数量控件
                var target = new QuantityPanelEx(this._orderItem, permissionCode, auth);
                target.CancelButtonClick += (o, args) => { };
                target.AcceptButtonClick += (o, args) =>
                {
                    StoreBusinessUtils.SaveOperationLog("204", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);
                    //判断是否是套餐主,同步更改套餐明细数量
                    if (this._orderItem.RowState == OrderRowState.套餐主)
                    {
                        var details = this._orderObject.Items.FindAll(x => x.ParentId == this._orderItem.Id && x.Group == this._orderItem.Group);
                        foreach (var item in details)
                        {
                            //道菜加价金额
                            item.SuitAmount = this._orderItem.Quantity * item.SuitAddPrice;

                            //道菜数量随主菜变化而增加
                            item.Quantity = this._orderItem.Quantity * item.SuitQuantity;

                            //将更改后的行数据同步到订单列表
                            var inx = this._orderObject.Maps.IndexOf(item);
                            this._orderObject.Maps[inx] = item;

                            RefreshRow(item);

                        }

                        //套餐道菜分摊
                        PromotionUtils.CalculateSuitShare(this._orderObject, this._orderItem);
                    }
                    //套餐主特殊处理
                    UpdateSuitMain(this._orderItem);

                    //刷新购物车
                    this.UpdateGridRow();
                    //刷新界面元素
                    this.RefreshUi();
                };

                //显示位置
                Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
                TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
                trans.Show(this);
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "加载数量修改异常");
            }
            finally
            {

            }

        }

        private void OrderItemQuantityPlus(object sender)
        {
            var refreshItems = BusinessUtils.Instance.OrderItemQuantityPlusEx(this._orderObject, this._orderItem);

            if (refreshItems.Item1)
            {
                StoreBusinessUtils.SaveOperationLog("204", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);

                foreach (var item in refreshItems.Item3)
                {
                    RefreshRow(item);
                }

                //套餐主特殊处理
                UpdateSuitMain(this._orderItem);

                //更新表格
                UpdateGridRow();

                //刷新界面元素
                this.RefreshUi();
            }
            else
            {
                this.ShowToastNotify(this, refreshItems.Item2);
            }

        }

        private void OrderItemQuantityMinus(object sender)
        {
            var refreshItems = BusinessUtils.Instance.OrderItemQuantityMinus(this._orderObject, this._orderItem);
            foreach (var item in refreshItems)
            {
                RefreshRow(item);
            }

            StoreBusinessUtils.SaveOperationLog("204", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);

            //套餐主特殊处理
            UpdateSuitMain(this._orderItem);

            //更新表格
            UpdateGridRow();

            //刷新界面元素
            this.RefreshUi();
        }

        private void OrderItemSuit(object sender, List<OrderItem> rows, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var button = sender as MetroTileItem;

            if (this._orderItem.RowState == OrderRowState.套餐主 || this._orderItem.RowState == OrderRowState.套餐明)
            {
                //要求
                var target = new SuitPanelEx(rows, permissionCode, authz);

                target.CancelButtonClick += (o, args) => { };
                target.NotifyChanged += (o, args) =>
                {
                    var item = args.Data as OrderItem;

                    //刷新购物车
                    this.UpdateGridRow(item);

                    //查找套餐主菜信息
                    var master = rows.ToList().Find(x => x.RowState == OrderRowState.套餐主);

                    var details = rows.ToList().FindAll(x => x.RowState == OrderRowState.套餐明);

                    master.Price = master.SalePrice + details.Sum(x => x.SuitAddPrice);

                    master.MemberPrice = master.MemberSalePrice + details.Sum(x => x.SuitAddPrice);

                    master.DiscountPrice = master.Price;

                    this.UpdateGridRow(master);

                    //套餐主特殊处理
                    UpdateSuitMain(this._orderItem);

                    //刷新界面元素
                    this.RefreshUiEx();

                    //分摊道菜优惠
                    PromotionUtils.CalculateSuitShare(this._orderObject, rows.ToList());

                };

                //显示位置
                Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
                TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
                trans.Show(this);
            }
        }


        private void OrderItemSpec(object sender, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var button = sender as MetroTileItem;
            //要求
            var target = new SpecPanelEx(orderItem, permissionCode, authz);
            target.CancelButtonClick += (o, args) => { };
            target.NotifyChanged += (o, args) =>
            {

                //清空该行所有的促销
                var list = BusinessUtils.Instance.RemoveOrderItemPromotion(this._orderObject, this._orderItem);

                foreach (var item in list)
                {
                    //刷新购物车
                    this.UpdateGridRow(item);
                }

                //刷新界面元素
                this.RefreshUi();
            };

            //显示位置
            Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
            TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
            trans.Show(this);
        }

        private void OrderItemFlavor(object sender, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            if (this._orderItem.RowState == OrderRowState.套餐主)
            {
                this.ShowToastNotify(this, "不允许在套菜主菜设置!");
                return;
            }

            var button = sender as MetroTileItem;
            //要求
            var target = new FlavorPanelEx(orderItem, permissionCode, authz);
            target.CancelButtonClick += (o, args) => { };
            target.NotifyChanged += (o, args) =>
            {

                //套餐主特殊处理
                UpdateSuitMain(this._orderItem);

                //刷新购物车
                this.UpdateGridRow();

                //刷新界面元素
                this.RefreshUi();
            };

            //显示位置
            Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
            TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
            trans.Show(this);
        }

        private void OrderItemMember(object sender)
        {
            MemberInfoQueryResponse memberInfo = null;
            bool isRechargeGo = false;
            var button = sender as MetroTileItem;
            //要求
            var target = new MemberPanelEx(this._orderObject.Member);
            target.CancelButtonClick += (o, args) => { };
            target.NotifyChanged += (o, args) =>
            {
                MemberInfoQueryResponse member = null;
                if (args.Data != null)
                {
                    member = args.Data as MemberInfoQueryResponse;
                    memberInfo = member;
                }
                //南宁定制需求,会员卡余额为0不允许刷卡
                if (member != null)
                {
                    var skipNoMoney = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_CARDPAYSKIPNOMONEY, "0");
                    if (member.CurrentCard.AvailableAmount <= 0 && "1".Equals(skipNoMoney))
                    {
                        isRechargeGo = true;
                        member = null;
                    }
                }
                //先判断是否已经完成
                if (this._orderObject.OrderStatus == OrderStatus.已完成)
                {
                    this.DestoryOrderObject(true);
                }
                //将刷卡信息添加给订单对象
                this._orderObject.Member = member;

                if (this._orderObject.Member != null)
                {
                    //修改会员卡号显示
                    string showCardNo = string.IsNullOrEmpty(this._orderObject.Member.CurrentCard.FaceNo) ? this._orderObject.Member.CurrentCard.CardNo : this._orderObject.Member.CurrentCard.FaceNo;

                    //会员卡号、姓名
                    this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), CardUtils.CardNoEncrypt(showCardNo));
                    //会员姓名
                    //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), this._orderObject.Member.Name);
                    //会员余额
                    this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), this._orderObject.Member.CurrentCard.AvailableAmount);
                    //会员积分
                    this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), this._orderObject.Member.CurrentCard.TotalPoint);

                    //使用会员优惠
                    bool isGo = true;
                    if (isGo && _orderObject.Promotions != null && _orderObject.Promotions.Count > 0)
                    {
                        isGo = false;
                    }
                    if (isGo)
                    {
                        foreach (var item in _orderObject.Items)
                        {
                            CalItemPromEngine(item);
                            //BusinessUtils.Instance.AddMemberPromotion(_orderObject, item);
                            //套餐道菜分摊
                            PromotionUtils.CalculateSuitShare(this._orderObject, item);
                        }
                        CalOrderPromEngine();

                        //刷新购物车
                        //this.UpdateGrid();//this.UpdateGridRow();

                        ////刷新界面元素
                        this.RefreshUiEx();
                    }

                    Task.Factory.StartNew(() =>
                    {
                        //查询会员优惠券，有则提示收银员当前会员有优惠券
                        var resp = CardUtils.QueryElecCoupon("mobile", _orderObject.Member.Mobile, "0", 1);
                        if (resp.Item1)
                        {
                            var list = resp.Item3;
                            if (list != null && list.Count > 0)
                            {
                                this.Invoke(new Action(() =>
                                {
                                    MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, list.Count));
                                    //this.ShowToastNotify(this, "会员优惠提示:该会员有可用优惠券哦!");
                                }));
                            }
                        }
                    });
                }
                else
                {
                    //会员卡号、姓名
                    this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), string.Empty);
                    //会员姓名
                    //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), string.Empty);
                    //会员余额
                    this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), string.Empty);
                    //会员积分
                    this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), string.Empty);

                    //取消会员优惠
                    BusinessUtils.Instance.RemoveMemberPromotion(_orderObject);

                    //关闭会员优惠提醒
                    MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, 0));

                    //刷新购物车
                    this.UpdateGrid();//this.UpdateGridRow();

                    //刷新界面元素
                    this.RefreshUi();
                }
                target.OnCancelButtonClick(new FlyoutEventArgs(FlyoutAction.Cancel, "cancel"));
                if (isRechargeGo)
                {
                    //修改会员卡号显示
                    string showCardNo = string.IsNullOrEmpty(memberInfo.CurrentCard.FaceNo) ? memberInfo.CurrentCard.CardNo : memberInfo.CurrentCard.FaceNo;
                    var dialogForm = new CardGoRechargeForm(memberInfo.Name, memberInfo.CurrentCard.CardNo, CardUtils.CardNoEncrypt(showCardNo), memberInfo.CurrentCard.AvailableAmount, memberInfo.CurrentCard.TotalPoint);
                    dialogForm.OnRechargeClick += OnTelephoneHistoryControlNotifyChanged;
                    dialogForm.ShowDialog();
                }
            };

            //显示位置
            Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
            TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
            trans.Show(this);
        }

        private void OrderItemDiscount(object sender, string permissionCode, AuthOperator auth = AuthOperator.输入操作, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var button = sender as MetroTileItem;
            //折扣控件
            var target = new DiscountPanelEx(ModuleKeyCode.折扣, this._orderItem, this._orderObject, permissionCode, auth, authz);
            target.CancelButtonClick += (o, args) => { };
            target.AcceptButtonClick += (o, args) =>
            {
                bool isGo = true;

                //整单折扣
                if (isGo && args.KeyCode.Equals("order") && args.Data is PromotionOrder)
                {
                    foreach (var item in this._orderObject.Items)
                    {
                        //有单品优惠禁止操作
                        if (item.Promotions != null && item.Promotions.FindAll(x => x.PromotionType != PromotionType.道菜分摊).Count > 0)
                        {
                            isGo = false;

                            break;
                        }
                    }

                    if (isGo)
                    {
                        var promotion = args.Data as PromotionOrder;

                        //重新计算优惠
                        PromotionUtils.Calculate(this._orderObject, promotion);

                        this._orderItem.Action = "整单折扣操作";

                        StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);
                    }
                    else
                    {
                        this.ShowToastNotify(this, "有单品享受优惠，操作无效");
                    }
                }

                if (isGo && args.KeyCode.Equals("item") && args.Data is PromotionItem)
                {

                    var promotionItem = args.Data as PromotionItem;

                    //重新计算优惠
                    PromotionUtils.Calculate(this._orderObject, this._orderItem, promotionItem);

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(this._orderObject, this._orderItem);

                    this._orderItem.Action = "单品折扣操作";

                    StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);
                }

                //更新表格全部
                UpdateGrid();

                //刷新界面元素
                this.RefreshUi();
            };

            //显示位置
            Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
            TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
            trans.Show(this);
        }

        private void OrderItemBargain(object sender, string permissionCode, AuthOperator auth = AuthOperator.输入操作, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var button = sender as MetroTileItem;
            //议价控件
            var target = new BargainPanelEx(ModuleKeyCode.议价, this._orderItem, this._orderObject, permissionCode, auth, authz);
            target.CancelButtonClick += (o, args) => { };
            target.AcceptButtonClick += (o, args) =>
            {
                if (args.KeyCode.Equals("order") && args.Data is PromotionOrder)
                {
                    bool isGo = true;

                    foreach (var item in this._orderObject.Items)
                    {
                        //有单品优惠禁止操作
                        if (item.Promotions != null && item.Promotions.FindAll(x => x.PromotionType != PromotionType.道菜分摊).Count > 0)
                        {
                            isGo = false;

                            break;
                        }
                    }

                    if (isGo)
                    {
                        var promotion = args.Data as PromotionOrder;

                        //重新计算优惠
                        PromotionUtils.Calculate(this._orderObject, promotion);
                    }
                    else
                    {
                        this.ShowToastNotify(this, "有单品享受优惠，操作无效");
                    }

                    //更新表格全部
                    UpdateGrid();

                    //刷新界面元素
                    this.RefreshUiEx();

                }

                if (args.KeyCode.Equals("item") && args.Data is PromotionItem)
                {
                    var promotionItem = args.Data as PromotionItem;

                    //重新计算优惠
                    PromotionUtils.Calculate(this._orderObject, this._orderItem, promotionItem);

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(this._orderObject, this._orderItem);

                    this._orderItem.Action = "单品议价操作";

                    StoreBusinessUtils.SaveOperationLog("303", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);

                    //更新表格全部
                    UpdateGridRow();

                    //刷新界面元素
                    this.RefreshUiEx();
                }


            };

            //显示位置
            Rectangle pointerBounds = new Rectangle(button.PointToScreen(button.Bounds.Location), button.Bounds.Size);
            TransparentShortcut trans = new TransparentShortcut(this.mainPanel, target, pointerBounds);
            trans.Show(this);
        }

        private void OrderRemovePromotion(object sender)
        {
            BusinessUtils.Instance.RemoveOrderPromotion(this._orderObject);

            StoreBusinessUtils.SaveOperationLog("304", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);

            //更新表格全部
            UpdateGrid();

            //重新计算整单优惠
            CalOrderPromEngine();

            //刷新界面元素
            this.RefreshUiEx();
        }

        private void OrderItemGive(object sender)
        {
            //提示
            var dialog = new DialogForm("赠送提示信息", "您确定要赠送<" + this._orderItem.DisplayName + ">?", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);
            if (DialogResult.OK == dialog.ShowDialog(this))
            {
                BusinessUtils.Instance.OrderItemGive(this._orderObject, this._orderItem);

                StoreBusinessUtils.SaveOperationLog("302", "单号:" + _orderObject.TradeNo + "商品:" + this._orderItem.ProductNo + this._orderItem.Name);

                //更新表格全部
                UpdateGrid();

                //刷新界面元素
                this.RefreshUi();
            }

        }


        private void MenuAction(object sender, int index, string keyCode, object keyData, string permissionCode)
        {
            //是否启用授权窗口
            var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);

            ModuleKeyCode _keyCode = ModuleKeyCode.None;
            Enum.TryParse<ModuleKeyCode>(keyCode, out _keyCode);

            switch (_keyCode)
            {
                case ModuleKeyCode.取消全单:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.CleanOrderObject();
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        this.CleanOrderObject();
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }


                    }
                    break;
                case ModuleKeyCode.删除单品:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.RemoveOrderItem();
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        this.RemoveOrderItem();
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }


                    }
                    break;
                case ModuleKeyCode.数量:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemQuantity(sender, permissionCode, AuthOperator.输入操作);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {

                                        this.OrderItemQuantity(sender, permissionCode, AuthOperator.授权操作);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.数量加:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemQuantityPlus(sender);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {

                                        this.OrderItemQuantityPlus(sender);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }


                    }
                    break;
                case ModuleKeyCode.数量减:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemQuantityMinus(sender);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {

                                        this.OrderItemQuantityMinus(sender);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }


                    }
                    break;
                case ModuleKeyCode.要求:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.ProcessFlavor(sender, this._orderItem, permissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessFlavor(sender, this._orderItem, permissionCode, authz);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }



                    }
                    break;
                case ModuleKeyCode.规格:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.ProcessSpec(sender, this._orderItem, permissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessSpec(sender, this._orderItem, permissionCode, authz);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.换菜:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo && !(this._orderItem.RowState == OrderRowState.套餐主 || this._orderItem.RowState == OrderRowState.套餐明))
                        {
                            this.ShowToastNotify(this, "不支持的操作!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //套餐关联的行集合，包含主菜和明细
                            var rows = this._orderObject.Items.FindAll(x => x.Id == this._orderItem.Id || x.ParentId == this._orderItem.Id).OrderBy(x => x.OrderNo);
                            if (this._orderItem.RowState == OrderRowState.套餐明)
                            {
                                rows = this._orderObject.Items.FindAll(x => x.Id == this._orderItem.ParentId || x.ParentId == this._orderItem.ParentId).OrderBy(x => x.OrderNo);
                            }

                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.ProcessSuit(sender, rows.ToList(), permissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessSuit(sender, rows.ToList(), permissionCode, authz);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }

                    }
                    break;
                case ModuleKeyCode.会员:
                    {
                        bool isGo = true;

                        //没有按钮权限
                        if (isGo && !isAuthz)
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemMember(sender);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.OrderItemMember(sender);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.赠送:
                    {
                        bool isGo = true;

                        var notAllowGive = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_GIVE, false);
                        //禁止收银前台赠送
                        if (isGo && notAllowGive)
                        {
                            this.ShowToastNotify(this, "禁止收银前台赠送!");
                            isGo = false;
                        }

                        //没有按钮权限
                        //if (isGo && !isAuthz)
                        //{
                        //    this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                        //    isGo = false;
                        //}

                        if (isGo)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemGive(sender);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), permissionCode, this._orderObject);
                                authForm.ExpectValidate(permissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.OrderItemGive(sender);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }

                    }
                    break;
                case ModuleKeyCode.折扣:
                    {
                        if (isAuthz)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemDiscount(sender, permissionCode, AuthOperator.输入操作);
                            }
                            else
                            {
                                this.OrderItemDiscount(sender, permissionCode, AuthOperator.授权操作);
                            }
                        }
                        else
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                        }


                    }
                    break;
                case ModuleKeyCode.议价:
                    {
                        if (isAuthz)
                        {
                            //有权限
                            if (Global.Instance.HasPermission(permissionCode))
                            {
                                this.OrderItemBargain(sender, permissionCode, AuthOperator.输入操作);
                            }
                            else
                            {
                                this.OrderItemBargain(sender, permissionCode, AuthOperator.授权操作);
                            }
                        }
                        else
                        {
                            this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                        }
                    }
                    break;
                case ModuleKeyCode.清零:
                    {
                        if (this.weightShowControl1.ClearZero())
                        {
                            this.ShowToastNotify(this, "清零成功！");
                        }
                        else
                        {
                            this.ShowToastNotify(this, "清零失败！！！");
                        }
                    }
                    break;
                case ModuleKeyCode.去皮:
                    {
                        if (this.weightShowControl1.PeelSkin())
                        {
                            this.ShowToastNotify(this, "去皮成功！");
                        }
                        else
                        {
                            this.ShowToastNotify(this, "去皮失败！！！");
                        }
                    }
                    break;
                case ModuleKeyCode.美团券://zhangy 2020-04-23 Add 添加美团券核销
                    {
                        this.MeituanCoupon(_keyCode, permissionCode);
                    }
                    break;
                default:
                    {
                        this.ShowToastNotify(this, "暂不可用,敬请期待!");
                    }
                    break;
            }
        }


        private void MeituanCoupon(ModuleKeyCode keyCode, string permissionCode)
        {
            bool isGo = true;

            //没有按钮权限
            if (isGo && string.IsNullOrEmpty(Global.StoreInfo.StoreInfoMessage.MeituanAppKey) && string.IsNullOrEmpty(Global.StoreInfo.StoreInfoMessage.MeituanAppSecret))
            {
                this.ShowToastNotify(this, "您目前无法操作该功能,系统尚未配置相关参数");
                isGo = false;
            }


            //1、先判断是否已经完成
            if (isGo && ((this._orderObject.OrderType == OrderType.电话外卖 && this._orderObject.OrderStatus == OrderStatus.等待付款) || this._orderObject.OrderStatus == OrderStatus.已完成))
            {
                this.DestoryOrderObject(true);
            }

            bool newTradeNo = this.NewTradeNo(this._orderObject);
            if (isGo && newTradeNo)
            {
                var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                {
                    var form = new MeituanCouponForm(this._orderObject);
                    form.CouponClick += OnMeituanCouponClick;
                    TransparentForm trans = new TransparentForm(this, form);
                    trans.Show(this);
                });

                var ret = AuthzUtils.Instance.CheckAuthz(this, keyCode, permissionCode, this._orderObject, action);
                if (!ret.Item1)
                {
                    this.ShowToastNotify(this, ret.Item2);
                }
            }
            else
            {
                LOGGER.Info("代金券操作发生错误");
            }
        }
        private void OnMeituanCouponClick(object sender, NotifyEventArgs e)
        {
            try
            {
                if (e.Data != null && e.Data is Tuple<string, CouponStatusQueryResponse, List<ProductExt>>)
                {
                    var obj = e.Data as Tuple<string, CouponStatusQueryResponse, List<ProductExt>>;

                    string couponCode = obj.Item1;

                    var data = obj.Item2;

                    var productList = obj.Item3;

                    switch (data.DealType)
                    {
                        case 1://代金券
                            {
                                foreach (var product in productList)
                                {
                                    //如果商品存在,就进行商品的添加
                                    var newOrderItem = BusinessUtils.Instance.NewOrderItem(_orderObject, product);
                                    AddGridRowEx(product, newOrderItem, false);
                                }

                                //zhangy 2020-05-19 美团券核销不计入优惠，屏蔽以下代码，按支付方式处理
                                //PromotionEntity prom = new PromotionEntity();
                                //prom.Type = PromotionType.美团团购券;
                                //prom.IsOrder = true;

                                ////包含商品，整单全优惠
                                //if(productList.Count > 0)
                                //{
                                //    prom.DiscountAmount = _orderObject.ReceivableAmount;
                                //}
                                //else
                                //{
                                //    var discountAmount = _orderObject.ReceivableAmount - data.DealValue;
                                //    prom.DiscountAmount = discountAmount > 0 ?  data.DealValue : _orderObject.ReceivableAmount;
                                //}

                                //prom.PromotionId = couponCode;                                
                                //prom.PromotionDesc = string.Format("[代金券]{0},售卖价格:{1},市场价格:{2}", data.DealTitle, data.DealPrice, data.DealValue);
                                //prom.CouponId = data.DealId.ToString();

                                //BusinessUtils.Instance.ApplyOrderPromotionMeituan(_orderObject, prom);

                                UpdateGrid();
                                RefreshUi();

                                //如果包含商品，自动核销
                                if (productList.Count > 0)
                                {
                                    string message = string.Format("美团代金券[{0}]验券通过，开始核销.....", couponCode);
                                    this.ShowToastNotify(this, message);

                                    QuickMeituanCouponPay(couponCode);
                                }
                                else
                                {
                                    string message = string.Format("美团代金券[{0}]验券通过，结账后核销", couponCode);
                                    this.ShowToastNotify(this, message);

                                    var meituanPayMode = OrderUtils.GetMeituanPayMode();
                                    //构建美团券支付方式
                                    PayItem item = OrderUtils.ToPayItem(meituanPayMode);
                                    //订单ID
                                    item.OrderId = _orderObject.Id;
                                    //收银票号
                                    item.TradeNo = _orderObject.TradeNo;

                                    //操作员输入的金额
                                    var amount = _orderObject.ReceivableAmount - data.DealValue;
                                    item.PaidAmount = amount > 0 ? data.DealValue : _orderObject.ReceivableAmount;

                                    //实收金额                                   
                                    item.Amount = item.PaidAmount;

                                    //找零金额
                                    item.ChangeAmount = 0;

                                    item.CardNo = "";
                                    item.Memo = "美团券核销";
                                    //美团券码
                                    item.TradeVoucherNo = couponCode;

                                    item.Status = (int)OrderPaymentStatus.已付款;
                                    item.StatusDesc = "美团券核销";

                                    item.PayTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                                    //将支付方式压入整单支付明细中
                                    _orderObject.Pays.Add(item);

                                    this._billForm.RefreshUi("12", this._orderObject);
                                    var trans = Application.OpenForms["TransparentFormExt"];
                                    if (trans == null)
                                    {
                                        trans = new TransparentFormExt(this, this._billForm);
                                    }
                                    trans.Visible = false;
                                    ((TransparentFormExt)trans).Show(this);

                                }
                            }
                            break;
                        case 2://套餐券
                            {
                                foreach (var product in productList)
                                {
                                    //如果商品存在,就进行商品的添加
                                    var newOrderItem = BusinessUtils.Instance.NewOrderItem(_orderObject, product);
                                    AddGridRowEx(product, newOrderItem, false);
                                }

                                //zhangy 2020-05-19 美团券核销不计入优惠，屏蔽以下代码，按支付方式处理
                                //PromotionEntity prom = new PromotionEntity();
                                //prom.Type = PromotionType.美团团购券;
                                //prom.IsOrder = true;

                                ////包含商品，整单全优惠
                                //prom.DiscountAmount = _orderObject.ReceivableAmount;
                                //prom.PromotionId = couponCode;
                                //prom.PromotionDesc = string.Format("[套餐券]{0},售卖价格:{1},市场价格:{2}", data.DealTitle,data.DealPrice,data.DealValue); 
                                //prom.CouponId = data.DealId.ToString();
                                //BusinessUtils.Instance.ApplyOrderPromotionMeituan(_orderObject, prom);

                                UpdateGrid();
                                RefreshUi();

                                string message = string.Format("套餐券[{0}]验券通过，开始核销.....", couponCode);
                                this.ShowToastNotify(this, message, 2000);


                                QuickMeituanCouponPay(couponCode);
                            }
                            break;
                    }

                }
                else
                {
                    this.ShowToastNotify(this, "美团券核销数据有错误，本次操作无效");
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "美团券核销发生异常");
            }
        }

        /// <summary>
        /// 美团券核销
        /// </summary>
        private void QuickMeituanCouponPay(string couponCode)
        {

            //自动弹出桌号
            if (!ProcessAutoDeskNo())
            {
                return;
            }

            var result = BusinessUtils.Instance.MeituanCouponPay(couponCode, _orderObject);

            if (result.Item1)
            {
                this.DestoryOrderObject(false);
            }
            else
            {
                this.ShowToastNotify(this, result.Item2);
            }
        }

        /// <summary>
        /// zhangy Add 2020-01-19 已结账状态下直接点击代金券，重建新订单
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        private bool NewTradeNo(OrderObject orderObject)
        {
            bool isGo = true;
            //2、判断订单号是否正常
            if (string.IsNullOrEmpty(orderObject.TradeNo))
            {
                //尝试重新获取一次单号
                var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                if (ticket.Item1)
                {
                    orderObject.TradeNo = ticket.Item3;
                }

                //重新判断是否获取到单号
                if (string.IsNullOrEmpty(orderObject.TradeNo))
                {
                    //是否提醒收银员
                    var isNofity = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_TICKET_NO_NOFITY, true);
                    //是否采用本机单号
                    var isLocalTicketNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_LOCAL_TICKET_NO, false);

                    string notifyMessage = "获取全局单号失败,收银参数禁止使用本机单号,请重新操作";

                    if (isNofity)
                    {
                        DialogForm dialog = null;
                        //采用本机单号
                        if (isLocalTicketNo)
                        {
                            notifyMessage = "获取全局单号失败,采用本机单号可能出现重复,是否继续?";
                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                        }
                        else
                        {
                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.OK);
                        }
                        //操作员选择了 是
                        if (DialogResult.Yes == dialog.ShowDialog())
                        {
                            orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                            isGo = true;
                        }
                        else
                        {
                            isGo = false;
                        }
                    }
                    else
                    {
                        if (isLocalTicketNo)
                        {
                            orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                            isGo = true;
                        }
                        else
                        {
                            this.ShowToastNotify(this, "获取全局单号失败,设置禁止使用本机单号,请重试");

                            isGo = false;
                        }
                    }
                }
            }

            return isGo;
        }

        /// <summary>
        /// 确保点击完成后继续，避免连击统一个按钮
        /// </summary>
        bool isDoubleHit = false;

        private void OnMenuMouseDown(object sender, Component.MenuEventArgs e)
        {
            if (!Global.Instance.AuthLogin)
            {
                LOGGER.Info("客户端到期禁止使用");
                var dialog = new DialogForm("特别提示", "您的POS使用权限已过期,请联系代理商续费!", MessageBoxIcon.Warning, MessageBoxButtons.OK);
                if (DialogResult.OK != dialog.ShowDialog())
                {
                    LOGGER.Info("到期自动退出系统");
                }
                return;
            }

            if (isDoubleHit)
            {
                LOGGER.Info("<{0}>连击事件,忽略本次点击", e.KeyCode);

                return;
            }

            isDoubleHit = true;

            //是否启用授权窗口
            var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);


            try
            {
                //校验是否继续
                var result = BusinessUtils.Instance.MenuOperateValidate(this._orderObject, this._orderItem, e.KeyCode);
                if (!result.Item1)
                {
                    ShowToastNotify(this, result.Item2);
                    return;
                }

                ModuleKeyCode _keyCode = ModuleKeyCode.None;
                Enum.TryParse<ModuleKeyCode>(e.KeyCode, out _keyCode);

                switch (_keyCode)
                {
                    case ModuleKeyCode.VK_0:
                    case ModuleKeyCode.VK_1:
                    case ModuleKeyCode.VK_2:
                    case ModuleKeyCode.VK_3:
                    case ModuleKeyCode.VK_4:
                    case ModuleKeyCode.VK_5:
                    case ModuleKeyCode.VK_6:
                    case ModuleKeyCode.VK_7:
                    case ModuleKeyCode.VK_8:
                    case ModuleKeyCode.VK_9:
                    case ModuleKeyCode.DOT:
                        {
                            this.txtCash.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map[e.KeyData.ToString()]);
                        }
                        break;
                    case ModuleKeyCode.VK_10:
                        {
                            this.txtCash.Text = string.Empty;
                            this.txtCash.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["1"]);
                            InputSimulatorUtils.SendKey(KeyCodes.Map["0"]);
                            this.txtCash.SelectAll();
                        }
                        break;
                    case ModuleKeyCode.VK_20:
                        {
                            this.txtCash.Text = string.Empty;
                            this.txtCash.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["2"]);
                            InputSimulatorUtils.SendKey(KeyCodes.Map["0"]);
                            this.txtCash.SelectAll();
                        }
                        break;
                    case ModuleKeyCode.VK_50:
                        {
                            this.txtCash.Text = string.Empty;
                            this.txtCash.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["5"]);
                            InputSimulatorUtils.SendKey(KeyCodes.Map["0"]);
                            this.txtCash.SelectAll();
                        }
                        break;
                    case ModuleKeyCode.VK_100:
                        {
                            this.txtCash.Text = string.Empty;
                            this.txtCash.Focus();
                            InputSimulatorUtils.SendKey(KeyCodes.Map["1"]);
                            InputSimulatorUtils.SendKey(KeyCodes.Map["0"]);
                            InputSimulatorUtils.SendKey(KeyCodes.Map["0"]);
                            this.txtCash.SelectAll();
                        }
                        break;
                    case ModuleKeyCode.CLEAR:
                        {
                            this.txtCash.Text = string.Empty;
                            this.txtCash.Focus();
                            this.txtCash.SelectAll();
                        }
                        break;
                    case ModuleKeyCode.桌号:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.SetDeskNo();
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.SetDeskNo();

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.现金结账:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                QuickPay();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.支付宝扫码:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                this._billForm.RefreshUi("04", this._orderObject);

                                var trans = Application.OpenForms["TransparentFormExt"];
                                if (trans == null)
                                {
                                    trans = new TransparentFormExt(this, this._billForm);
                                }
                                trans.Visible = false;
                                ((TransparentFormExt)trans).Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.微信扫码:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                this._billForm.RefreshUi("05", this._orderObject);

                                var trans = Application.OpenForms["TransparentFormExt"];
                                if (trans == null)
                                {
                                    trans = new TransparentFormExt(this, this._billForm);
                                }
                                trans.Visible = false;
                                ((TransparentFormExt)trans).Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员卡:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                bool quickPay = false;//快速支付
                                                      //判断是否符合快速支付
                                if (this._orderObject.ReceivableAmount > 0 && this._orderObject.Member != null && this._orderObject.Member.CurrentCard != null)
                                {
                                    var currentCard = this._orderObject.Member.CurrentCard;
                                    //会员规则
                                    var currentCardItem = JsonUtils.Deserialize<MemberCardItem>(Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_MEMBER_CARD));
                                    //是否启用免密支付,前台收银参数中关闭免密支付
                                    bool allowNoPwd = currentCardItem.PaymentType == 1;

                                    //1)卡设置开启免密支付；2)开启免密支付，且免密支付额度大于支付金额；3）收银参数开启免密支付 4)通过安全验证（读卡器读卡、电子卡扫码） 5)
                                    if (allowNoPwd && currentCard.IsNoPwd == 1 && currentCard.NpAmount >= this._orderObject.PaidAmount && this._orderObject.Member.GetWay != MemberCardNoType.手机号
                                    && this._orderObject.PaidAmount <= currentCard.AvailableAmount)
                                    {
                                        quickPay = true;
                                    }
                                }
                                if (quickPay)
                                {
                                    TransparentForm trans = new TransparentForm(this, 0.01, new CardPayForm(this._orderObject));
                                    trans.Show(this);
                                }
                                else
                                {
                                    this._billForm.RefreshUi("02", this._orderObject);

                                    var trans = Application.OpenForms["TransparentFormExt"];
                                    if (trans == null)
                                    {
                                        trans = new TransparentFormExt(this, this._billForm);
                                    }
                                    trans.Visible = false;
                                    ((TransparentFormExt)trans).Show(this);
                                }
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;

                    case ModuleKeyCode.其他支付:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                this._billForm.RefreshUi("01", this._orderObject);

                                var trans = Application.OpenForms["TransparentFormExt"];
                                if (trans == null)
                                {
                                    trans = new TransparentFormExt(this, this._billForm);
                                }
                                trans.Visible = false;
                                ((TransparentFormExt)trans).Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.扫码支付:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                this._billForm.RefreshUi("00", this._orderObject);

                                var trans = Application.OpenForms["TransparentFormExt"];
                                if (trans == null)
                                {
                                    trans = new TransparentFormExt(this, this._billForm);
                                }
                                trans.Visible = false;
                                ((TransparentFormExt)trans).Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.自定义支付:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //自动弹出桌号
                                if (!ProcessAutoDeskNo())
                                {
                                    return;
                                }

                                this._billForm.RefreshUi(e.KeyData.ToString(), this._orderObject);

                                var trans = Application.OpenForms["TransparentFormExt"];
                                if (trans == null)
                                {
                                    trans = new TransparentFormExt(this, this._billForm);
                                }
                                trans.Visible = false;
                                ((TransparentFormExt)trans).Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.挂单:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessGd(true, null);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessGd(true, null);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.取单:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessQd();
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessQd();

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.外带://10014
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //堂食外带切换
                                if (this._orderObject.OrderType == OrderType.堂食)
                                {
                                    this._orderObject.OrderType = OrderType.外带;
                                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.外带.ToString()) });
                                }
                                else
                                {
                                    this._orderObject.OrderType = OrderType.堂食;
                                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.堂食.ToString()) });
                                }


                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.门店外卖://301
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                //获取来电电话
                                string phoneNo = this.historyControl.GetPhoneNo();

                                var obj = new TelephoneNotifyObject();
                                obj.Telephone = phoneNo;
                                obj.MessageId = -1;

                                //电话外卖功能
                                OpenDeliveryForm(obj);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.饿了么://302
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["EleMeForm"];
                                if (form == null)
                                {
                                    form = new EleMeForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break; 
                        //zhangy 2020-02-22 Add 去除百度外卖的应用
                    //case ModuleKeyCode.百度外卖://304
                    //    {
                    //        var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                    //        {
                    //            var form = Application.OpenForms["BaiduForm"];
                    //            if (form == null)
                    //            {
                    //                form = new BaiduForm();
                    //            }
                    //            form.WindowState = FormWindowState.Maximized;
                    //            form.BringToFront();
                    //            form.Show();
                    //        });

                    //        var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                    //        if (!ret.Item1)
                    //        {
                    //            this.ShowToastNotify(this, ret.Item2);
                    //        }

                    //    }
                    //    break;
                    case ModuleKeyCode.微信订单://305
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["WeiXinForm"];
                                if (form == null)
                                {
                                    form = new WeiXinForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.QM小程序订单://307
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["QiMaiForm"];
                                if (form == null)
                                {
                                    form = new QiMaiForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.会员卡开户://401
                        {


                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((arg) =>
                            {
                                var dialogForm = new CardOpenForm();
                                dialogForm.OnRechargeClick += OnTelephoneHistoryControlNotifyChanged;
                                dialogForm.AcceptButtonClick += (o, args) =>
                                {
                                    if (args.Data is MemberInfoQueryResponse)
                                    {
                                        var response = args.Data as MemberInfoQueryResponse;

                                        //会员登记小票打印
                                        Task.Factory.StartNew(() =>
                                    {
                                        var storeNo = Global.Instance.Authc.StoreNo;
                                        var storeName = Global.Instance.Worker.StoreInfo.PrintName;
                                        var posNo = Global.Instance.Authc.PosNo;
                                        var workerNo = Global.Instance.Worker.No;
                                        var workerName = Global.Instance.Worker.Name;

                                        //构建收银小票模版参数
                                        var vars = PrintHelper.BuilderMemberRegisterVariable(storeNo, storeName, workerNo, workerName, posNo, response);

                                        //自动切纸
                                        bool cutPager = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_CASHIER_ALLOW_CUT_PAGER, false);

                                        LOGGER.Info("开始打印会员登记小票");

                                        //执行收银小票打印
                                        return PrintHelper.PrinterMemberRegister("会员登记单", vars, cutPager);


                                    }).ContinueWith(task =>
                                {

                                    if (task.IsFaulted)
                                    {
                                        LOGGER.Error(task.Exception.GetBaseException());
                                    }
                                    else
                                    {
                                        LOGGER.Info("会员登记小票打印结果<{0},{1}>", task.Result.Item1, task.Result.Item2);
                                    }
                                });
                                    }

                                };
                                dialogForm.CancelButtonClick += (o, args) => { };

                                TransparentForm trans = new TransparentForm(this, dialogForm);
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员合并://402
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardMergeForm2());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员卡充值://402
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                if (e.KeyData == null)
                                {
                                    TransparentForm trans = new TransparentForm(this, new CardRechargeForm());
                                    trans.Show(this);
                                }
                                else
                                {
                                    TransparentForm trans = new TransparentForm(this, new CardRechargeForm(e.KeyData.ToString()));
                                    trans.Show(this);
                                }

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.自定义充值://402
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardRechargeFreeFrom());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.充值记录查询://402
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardRechargeLogForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.礼品卡销售://403
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new GiftCardForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.美团外卖: 
                        {

                            if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLESHOPMEITUAN))
                            {
                                var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                                {
                                    var form = Application.OpenForms["SJMeituanForm"];
                                    if (form == null)
                                    {
                                        form = new SJMeituanForm();
                                    }
                                    form.WindowState = FormWindowState.Maximized;
                                    form.BringToFront();
                                    form.Show();
                                });

                                var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                                if (!ret.Item1)
                                {
                                    this.ShowToastNotify(this, ret.Item2);
                                }
                            }
                            else
                            {
                                var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                                {
                                    var form = Application.OpenForms["MeituanForm"];
                                    if (form == null)
                                    {
                                        form = new MeituanForm();
                                    }
                                    form.WindowState = FormWindowState.Maximized;
                                    form.BringToFront();
                                    form.Show();
                                });

                                var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                                if (!ret.Item1)
                                {
                                    this.ShowToastNotify(this, ret.Item2);
                                }
                            }
                        }
                        break;
                    case ModuleKeyCode.美团订单://309
                        {
                            //var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            //{
                            var _msid = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_GUOPANMSID, "");
                            var _key = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_GUOPANKEY, "");

                            if (string.IsNullOrEmpty(_msid) || string.IsNullOrEmpty(_key))
                            {
                                this.ShowToastNotify(this, "请配置后打开!");
                                return;
                            }

                            var _en = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEMEITUANORDER, false);//禁止使用;


                            if (_en)
                            {
                                this.ShowToastNotify(this, "功能已停止使用!");
                                return;
                            }
                            if (Global.Instance.Worker.TenantId.Equals("771200"))
                            {
                                this.ShowToastNotify(this, "功能已停止使用!");
                                return;
                            }
                            var form = Application.OpenForms["GuoPanOrderForm"];
                            if (form == null)
                            {
                                form = new GuoPanOrderForm();
                            }
                            form.WindowState = FormWindowState.Maximized;
                            form.BringToFront();
                            form.Show();

                            //});

                            //var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            //if (!ret.Item1)
                            //{
                            //    this.ShowToastNotify(this, ret.Item2);
                            //}
                        }
                        break;
                    case ModuleKeyCode.礼品卡销售记录://403
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new GiftCardFormTicket());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员查询://404
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardMessageForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.修改卡密码://405
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardEditPwdForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员退卡://406
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardAccountDestroyForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.积分兑换://407
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new PointExchangeForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.积分合并://408
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                Console.WriteLine("这里开始替换");
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.门店消费查询://409
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardConsumeHistoryForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.金额变动历史://410
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardAmountChangeForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.积分变动历史://411
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardPointChangeForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员换卡://413
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardExchangeForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.门店会员查询://414
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new MemberInfoListForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员日志://415
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new MemberHistoryForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.密码重置://417
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CardPwdResetForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.卡券核销记录://418
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new CouponConsumeRecordForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.代金券://10017
                        {
                            bool isGo = true;

                            //1、先判断是否已经完成
                            if ((this._orderObject.OrderType == OrderType.电话外卖 && this._orderObject.OrderStatus == OrderStatus.等待付款) || this._orderObject.OrderStatus == OrderStatus.已完成)
                            {
                                this.DestoryOrderObject(true);
                            }

                            isGo = this.NewTradeNo(this._orderObject);
                            if (isGo)
                            {
                                var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                                {
                                    var form = new CouponForm(this._orderObject);
                                    form.CouponClick += OnMemberCouponClick;
                                    TransparentForm trans = new TransparentForm(this, form);
                                    trans.Show(this);
                                });

                                var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                                if (!ret.Item1)
                                {
                                    this.ShowToastNotify(this, ret.Item2);
                                }
                            }
                            else
                            {
                                LOGGER.Info("代金券操作发生错误");
                            }

                            
                        }
                        break;
                    case ModuleKeyCode.会员价://404
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                //使用会员优惠
                                bool isGo = true;
                                if (isGo && _orderObject.Promotions != null && _orderObject.Promotions.Count > 0)
                                {
                                    isGo = false;
                                }
                                if (isGo)
                                {
                                    _orderObject.IsUserMemberPrice = true;
                                    foreach (var item in _orderObject.Items)
                                    {
                                        CalItemPromEngine(item);
                                        //BusinessUtils.Instance.AddMemberPromotion(_orderObject, item);
                                        //套餐道菜分摊
                                        PromotionUtils.CalculateSuitShare(this._orderObject, item);
                                    }
                                    CalOrderPromEngine();

                                    //刷新购物车
                                    //this.UpdateGrid();//this.UpdateGridRow();
                                    ////刷新界面元素
                                    this.RefreshUiEx();
                                    this.ShowToastNotify(this, "使用会员价");
                                }
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.云参数上传://10017
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new PosSetForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.要货单://701
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new AskGoodsListForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }

                        }
                        break;
                    case ModuleKeyCode.入库单://702
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["StoreStorageInListForm"];
                                if (form == null)
                                {
                                    form = new StoreStorageInListForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.配送验收://703
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new DispatchTicketListForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.库存盘点://704
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new StoreStockCheckForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.库存查询://705
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new ProductStockForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.商品耗料://712
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                TransparentForm trans = new TransparentForm(this, new ProductStockOutSummaryForm());
                                trans.Show(this);
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.报损单://706
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["StoreStorageLossListForm"];
                                if (form == null)
                                {
                                    form = new StoreStorageLossListForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.耗料单://707
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                var form = Application.OpenForms["StoreStorageConsumeListForm"];
                                if (form == null)
                                {
                                    form = new StoreStorageConsumeListForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.要货账户://708
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                Console.WriteLine("这里开始替换");
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.要货充值://709
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                Console.WriteLine("这里开始替换");
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.账单查询://710
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                Console.WriteLine("这里开始替换");
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.发票申请://711
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                Console.WriteLine("这里开始替换");
                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);
                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.取消优惠:
                        {
                            //有权限
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this._orderObject.IsUserMemberPrice = false;
                                this.OrderRemovePromotion(sender);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);
                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.OrderRemovePromotion(sender);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.单品赠送:
                        {
                            bool isGo = true;

                            var notAllowGive = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_GIVE, false);
                            //禁止收银前台赠送
                            if (isGo && notAllowGive)
                            {
                                this.ShowToastNotify(this, "禁止收银前台赠送!");
                                isGo = false;
                            }

                            //没有按钮权限
                            if (isGo && !isAuthz)
                            {
                                this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                                isGo = false;
                            }

                            if (isGo)
                            {
                                //有权限
                                if (Global.Instance.HasPermission(e.PermissionCode))
                                {
                                    this.OrderItemGive(sender);
                                }
                                else
                                {
                                    var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);
                                    authForm.ExpectValidate(e.PermissionCode);

                                    authForm.AcceptButtonClick += (o, args) =>
                                    {

                                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                        {
                                            //授权人权限信息
                                            var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                            this.OrderItemGive(sender);
                                        }
                                    };

                                    authForm.CancelButtonClick += (o, args) => { };
                                    TransparentForm trans = new TransparentForm(this, authForm);
                                    trans.Show(this);
                                }
                            }
                        }
                        break;
                    case ModuleKeyCode.整单折扣:
                    case ModuleKeyCode.单品折扣:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessDiscount(_keyCode, this._orderObject, this._orderItem, e.PermissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);
                                authForm.ExpectValidate(e.PermissionCode);
                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessDiscount(_keyCode, this._orderObject, this._orderItem, e.PermissionCode, authz);

                                    }

                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.单品议价:
                    case ModuleKeyCode.整单议价:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessBargain(_keyCode, this._orderObject, this._orderItem, e.PermissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessBargain(_keyCode, this._orderObject, this._orderItem, e.PermissionCode, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }

                        }
                        break;
                    case ModuleKeyCode.单品立减:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessErect(_keyCode, e.ModuleMenu, this._orderObject, this._orderItem, e.PermissionCode);
                            }
                            else
                            {
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;
                                        this.ProcessErect(_keyCode, e.ModuleMenu, this._orderObject, this._orderItem, e.PermissionCode, authz);
                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.整单立减:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessErect(_keyCode, e.ModuleMenu, this._orderObject, this._orderItem, e.PermissionCode);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessErect(_keyCode, e.ModuleMenu, this._orderObject, this._orderItem, e.PermissionCode, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.单品定额优惠:
                        {

                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessLj(e.ModuleMenu, this._orderObject, this._orderItem);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessLj(e.ModuleMenu, this._orderObject, this._orderItem, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.整单定额优惠:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessOrderLj(e.ModuleMenu, this._orderObject);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessOrderLj(e.ModuleMenu, this._orderObject, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.单品定率折扣:
                    case ModuleKeyCode.整单定率折扣:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessQuickDiscount(e.ModuleMenu, this._orderObject);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessQuickDiscount(e.ModuleMenu, this._orderObject, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.免单:
                        {
                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.ProcessMd(e.ModuleMenu, this._orderObject);
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.ProcessMd(e.ModuleMenu, this._orderObject, authz);

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.优惠券:
                        {

                            if (Global.Instance.HasPermission(e.PermissionCode))
                            {
                                this.SelectProductCouponDialog();
                            }
                            else
                            {
                                //菜单授权
                                var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);

                                authForm.ExpectValidate(e.PermissionCode);

                                authForm.AcceptButtonClick += (o, args) =>
                                {

                                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                    {
                                        //授权人权限信息
                                        var authz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                        this.SelectProductCouponDialog();

                                    }
                                };

                                authForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, authForm);
                                trans.Show(this);
                            }
                        }
                        break;
                    case ModuleKeyCode.登录密码:
                        {
                            bool isGo = true;

                            if (!Global.Instance.Online)
                            {
                                this.ShowToastNotify(this, "登录密码只支持联网状态修改！");
                                isGo = false;
                            }

                            if (isGo)
                            {
                                var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                                {

                                    TransparentForm trans = new TransparentForm(this, new EditUserPasswdForm());
                                    trans.Show(this);

                                });

                                var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.交班:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                //是否是盲交模式
                                bool ShiftMode = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_SHIFTMODE, false);
                                if (ShiftMode)
                                {
                                    TransparentForm trans = new TransparentForm(this, new ShiftBlindForm());
                                    trans.Show(this);
                                }
                                else
                                {
                                    TransparentForm trans = new TransparentForm(this, new ShiftForm());
                                    trans.Show(this);
                                }

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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


                        }
                        break;
                    case ModuleKeyCode.非营业支出:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                TransparentForm trans = new TransparentForm(this, new StoreCostForm());
                                trans.Show(this);

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.非营业收入:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                TransparentForm trans = new TransparentForm(this, new StoreRevenueForm());
                                trans.Show(this);

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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


                        }
                        break;
                    case ModuleKeyCode.备用金:
                        {
                            TransparentForm trans = new TransparentForm(this, new WorkerImprestForm());
                            trans.Show(this);
                        }
                        break;
                    case ModuleKeyCode.销售流水:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["SaleDetail"];
                                if (form == null)
                                {
                                    form = new SaleDetail();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.销售汇总:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["SaleSummary"];
                                if (form == null)
                                {
                                    form = new SaleSummary();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.桌台汇总:
                        {
                            var form = Application.OpenForms["DesktopReport"];
                            if (form == null)
                            {
                                form = new DesktopReport();
                            }
                            form.WindowState = FormWindowState.Maximized;
                            form.BringToFront();
                            form.Show();
                        }
                        break;
                    case ModuleKeyCode.收银报表:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["PaySummary"];
                                if (form == null)
                                {
                                    form = new PaySummary();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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


                        }
                        break;
                    case ModuleKeyCode.时段报表:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["TimeSummary"];
                                if (form == null)
                                {
                                    form = new TimeSummary();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();
                            });
                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.营业日报:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["DaySaleReport"];
                                if (form == null)
                                {
                                    form = new DaySaleReport();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.交班查询:
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["ShiftDetail"];
                                if (form == null)
                                {
                                    form = new ShiftDetail();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.操作监控:
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["OperationLogForm"];
                                if (form == null)
                                {
                                    form = new OperationLogForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.外卖汇总:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["OtherWaiMaiSummaryForm"];
                                if (form == null)
                                {
                                    form = new OtherWaiMaiSummaryForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.外送汇总:
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["DeliveryManager"];
                                if (form == null)
                                {
                                    form = new DeliveryManager();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.开钱箱:
                        {

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                StoreBusinessUtils.SaveOperationLog("202", null);

                                PrintHelper.OpenCashBox();

                            });

                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                        }
                        break;
                    case ModuleKeyCode.沽清:
                        {

                            bool isGo = true;

                            //没有按钮权限
                            if (isGo && !isAuthz)
                            {
                                this.ShowToastNotify(this, "您目前没有操作该功能的权限!");
                                isGo = false;
                            }


                            if (isGo)
                            {
                                var scf = new SaleClearForm();

                                scf.WindowState = FormWindowState.Maximized;

                                //有权限
                                if (Global.Instance.HasPermission(e.PermissionCode))
                                {
                                    var trans = new TransparentForm(this, scf);
                                    trans.Show();
                                }
                                else
                                {
                                    var authForm = new AuthDialogForm(_keyCode.ToString(), e.PermissionCode, this._orderObject);
                                    authForm.ExpectValidate(e.PermissionCode);

                                    authForm.AcceptButtonClick += (o, args) =>
                                    {

                                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                                        {
                                            this.Invoke(new Action(() =>
                                            {
                                                var _trans = new TransparentForm(this, scf);
                                                _trans.Show();
                                            }));


                                        }
                                    };

                                    authForm.CancelButtonClick += (o, args) => { };
                                    TransparentForm trans = new TransparentForm(this, authForm);
                                    trans.Show(this);
                                }
                            }

                        }
                        break;
                    case ModuleKeyCode.微信商品管理://306
                        {
                            if (!Global.Instance.Online)
                            {
                                this.ShowToastNotify(this, "网络不稳定或脱机模式下，无法使用本功能");

                                return;
                            }

                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {
                                //开启小程序点餐
                                bool enableAppletOrder = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEAPPLETORDER, true);
                                if (enableAppletOrder)
                                {
                                    var form = Application.OpenForms["WeixinMiniProgramForm"];
                                    if (form == null)
                                    {
                                        form = new WeixinProgramForm();
                                    }
                                    form.WindowState = FormWindowState.Maximized;
                                    form.BringToFront();
                                    form.Show();
                                }
                                else
                                {
                                    var form = Application.OpenForms["WeiXinProductForm"];
                                    if (form == null)
                                    {
                                        form = new WeiXinProductForm();
                                    }
                                    form.WindowState = FormWindowState.Maximized;
                                    form.BringToFront();
                                    form.Show();
                                }
                            });


                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

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

                            //var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            //{

                            //    var form = Application.OpenForms["WeiXinProductForm"];
                            //    if (form == null)
                            //    {
                            //        form = new WeiXinProductForm();
                            //    }
                            //    form.WindowState = FormWindowState.Maximized;
                            //    form.BringToFront();
                            //    form.Show();

                            //});

                            //var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            //if (!ret.Item1)
                            //{
                            //    this.ShowToastNotify(this, ret.Item2);
                            //}
                        }
                        break;
                    case ModuleKeyCode.卡消费汇总://419
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                var form = Application.OpenForms["CardConsumeSummaryForm"];
                                if (form == null)
                                {
                                    form = new CardConsumeSummaryForm();
                                }
                                form.WindowState = FormWindowState.Maximized;
                                form.BringToFront();
                                form.Show();

                            });
                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.会员信息变更://420
                        {
                            var action = new Action<Tuple<decimal, decimal, List<string>, Worker>>((args) =>
                            {

                                TransparentForm trans = new TransparentForm(this, new CardUpdateFrom());
                                trans.Show(this);
                            });
                            var ret = AuthzUtils.Instance.CheckAuthz(this, _keyCode, e.PermissionCode, this._orderObject, action);

                            if (!ret.Item1)
                            {
                                this.ShowToastNotify(this, ret.Item2);
                            }
                        }
                        break;
                    case ModuleKeyCode.美团券核销://zhangy 2020-04-24 Add 美团团购券核销历史数据
                        {

                            var form = Application.OpenForms["MeituanCouponReportForm"];
                            if (form == null)
                            {
                                form = new MeituanCouponReportForm();
                            }
                            form.WindowState = FormWindowState.Maximized;
                            form.BringToFront();
                            form.Show();
                        }
                        break;
                    case ModuleKeyCode.美团券://zhangy 2020-04-23 Add 添加美团券核销
                        {
                            this.MeituanCoupon(_keyCode, e.PermissionCode);
                        }
                        break;
                    default:
                        {
                            this.ShowToastNotify(this, "暂不可用,敬请期待!");
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "OnMenuMouseDown异常");
            }
            finally
            {
                isDoubleHit = false;
            }
        }

        private void OnMemberCouponClick(object sender, NotifyEventArgs e)
        {
            var data = e.Data as ElectronCoupon;

            var status = (MemberCouponStatus)data.ErrorType;
            if (status == MemberCouponStatus.可用)
            {
                //第一步进行核销前校验
                var result = CardUtils.CheckCouponConsume(data.Code, (int)(this._orderObject.Amount * 100));
                if (!result.Item1)
                {
                    var dialog = new DialogForm("核销兑换券失败提醒", string.Format("核销失败！原因:{0}", result.Item2), MessageBoxIcon.Error, MessageBoxButtons.OK);
                    dialog.TopLevel = true;
                    dialog.ShowDialog(this);
                    return;
                }
                //第二步优惠券是否已经在核销列表
                bool isCanUse = false;
                if (this._orderObject != null && this._orderObject.Items != null)
                {
                    foreach (OrderItem item in this._orderObject.Items)
                    {
                        if (item.Promotions != null)
                        {
                            List<PromotionItem> promotionList = item.Promotions.FindAll(x => data.Code.Equals(x.PlanNo));
                            if (promotionList != null && promotionList.Count > 0)
                            {
                                isCanUse = true;
                            }
                        }
                    }
                }
                if (isCanUse)
                {
                    //非法
                    var dialog = new DialogForm("验证失败提醒", string.Format("<{0}>优惠券已经在使用列表中,请勿重复使用", data.Title), MessageBoxIcon.Error, MessageBoxButtons.OK);
                    dialog.TopLevel = true;
                    dialog.ShowDialog(this);
                    return;
                }

                var validAmount = PromotionUtils.GetValidPromItemsAmount(_orderObject);
                if (_orderObject.Member == null)
                {
                    LOGGER.Info("优惠券获取会员成功");
                    //模拟会员刷卡动作
                    MemberInfoQueryRequest request = new MemberInfoQueryRequest();
                    request.Keyword = data.MemberId;
                    request.Property = "mebId";
                    request.ShopNo = Global.Instance.Authc.StoreNo;
                    request.WorkerNo = Global.Instance.Worker.No;
                    request.PosNo = Global.Instance.Authc.PosNo;
                    var respMemberInfoQuery = CardUtils.MemberInfoQuery(request);
                    //会员卡获取成功
                    if (respMemberInfoQuery.Item1)
                    {
                        //将刷卡信息添加给订单对象
                        this._orderObject.Member = respMemberInfoQuery.Item3;
                        if (this._orderObject.Member != null)
                        {
                            this._orderObject.Member.CurrentCard = this._orderObject.Member.CardList[0];
                            //修改会员卡号显示
                            string showCardNo = string.IsNullOrEmpty(this._orderObject.Member.CurrentCard.FaceNo) ? this._orderObject.Member.CurrentCard.CardNo : this._orderObject.Member.CurrentCard.FaceNo;

                            //会员卡号、姓名
                            this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), CardUtils.CardNoEncrypt(showCardNo));
                            //会员姓名
                            //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), this._orderObject.Member.Name);
                            //会员余额
                            this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), this._orderObject.Member.CurrentCard.AvailableAmount);
                            //会员积分
                            this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), this._orderObject.Member.CurrentCard.TotalPoint);

                            //使用会员优惠
                            bool isGo = true;
                            if (isGo && _orderObject.Promotions != null && _orderObject.Promotions.Count > 0)
                            {
                                isGo = false;
                            }
                            if (isGo)
                            {
                                foreach (var item in _orderObject.Items)
                                {
                                    CalItemPromEngine(item);
                                    //BusinessUtils.Instance.AddMemberPromotion(_orderObject, item);
                                    //套餐道菜分摊
                                    PromotionUtils.CalculateSuitShare(this._orderObject, item);
                                }
                                CalOrderPromEngine();

                                //刷新购物车
                                //this.UpdateGrid();//this.UpdateGridRow();

                                ////刷新界面元素
                                this.RefreshUiEx();
                            }

                            Task.Factory.StartNew(() =>
                            {
                                //查询会员优惠券，有则提示收银员当前会员有优惠券
                                var resp = CardUtils.QueryElecCoupon("mobile", _orderObject.Member.Mobile, "0", 1);
                                if (resp.Item1)
                                {
                                    var list = resp.Item3;
                                    if (list != null && list.Count > 0)
                                    {
                                        this.Invoke(new Action(() =>
                                        {
                                            MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, list.Count));
                                            //this.ShowToastNotify(this, "会员优惠提示:该会员有可用优惠券哦!");
                                        }));
                                    }
                                }
                            });
                        }
                    }
                }
                else
                {
                    if (!data.MemberId.Equals(_orderObject.Member.Id))
                    {
                        var confirm = new DialogForm("优惠券不可用提示", "优惠券不是当前会员的优惠券,无法使用", MessageBoxIcon.Error, MessageBoxButtons.OK);
                        confirm.TopLevel = true;
                        confirm.ShowDialog();
                        return;
                    }
                }
                //最低消费金额是否满足
                var checkAmount = PromotionUtils.GetValidPromItemsByCoupon(_orderObject, data.CardType);
                if (data.LeastCost > 0)
                {
                    //可以参与优惠的金额
                    var tempLeast = data.LeastCost / 100M;
                    if (checkAmount < tempLeast)
                    {
                        var confirm = new DialogForm("优惠券不可用提示", "未达最低消费额!", MessageBoxIcon.Error, MessageBoxButtons.OK);
                        confirm.TopLevel = true;
                        confirm.ShowDialog();
                        return;
                    }
                }
                PromotionEntity prom = new PromotionEntity();
                ProductExt product = null;
                OrderItem newOrderItem = null;
                switch (data.CardType)
                {
                    case MemberCouponType.DISCOUNT:
                        {
                            prom.Type = PromotionType.电子折扣券;
                            var discount = (1M - data.Discount / 10M);
                            var disAmount = validAmount * discount;
                            if (disAmount <= validAmount)
                            {
                                prom.DiscountAmount = disAmount;
                            }
                            else
                            {
                                prom.DiscountAmount = validAmount;
                            }
                        }
                        break;
                    case MemberCouponType.CASH:
                        {
                            prom.Type = PromotionType.电子代金券;
                            var reduceCost = data.ReduceCost / 100M;
                            var tempLeast = data.LeastCost / 100M;//最低消费金额
                                                                  //如果最低消费金额大于零,就判断是否使用过券
                            if (tempLeast > 0 && _orderObject.Promotions != null && _orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.电子代金券).Count > 0)
                            {
                                var confirm = new DialogForm("优惠券不可用提示", "已使用过代金券,不能再使用有最低消费金额的代金券！", MessageBoxIcon.Error, MessageBoxButtons.OK);
                                confirm.TopLevel = true;
                                confirm.ShowDialog();
                                return;
                            }
                            if (reduceCost <= _orderObject.ProductReceivableAmount)
                            {
                                prom.DiscountAmount = reduceCost;
                            }
                            else if (_orderObject.ProductReceivableAmount == 0)
                            {
                                var confirm = new DialogForm("优惠券不可用提示", "可优惠金额为零，不能使用！", MessageBoxIcon.Error, MessageBoxButtons.OK);
                                confirm.TopLevel = true;
                                confirm.ShowDialog();
                                return;
                            }
                            else
                            {
                                prom.DiscountAmount = _orderObject.ProductReceivableAmount;
                            }
                            prom.IsOrder = true;
                            prom.PromotionId = data.Code;
                            prom.PromotionDesc = data.Title;
                            prom.CouponId = data.CouponId;
                            BusinessUtils.Instance.ApplyOrderPromotionDZDJQ(_orderObject, prom);
                            UpdateGrid();
                            RefreshUi();
                            data.ErrorType = (int)MemberCouponStatus.使用中;
                            data.RealMoney = prom.DiscountAmount;
                            MsgEvent.Send(Constant.MEMBERCOUPON_CHANGE_NOTIFY, new Tuple<ElectronCoupon, bool>(data, true));
                            this.ShowToastNotify(this, string.Format("成功使用<{0}>,优惠<{1}>元", data.Title, prom.DiscountAmount), 3000);
                            return;
                        }
                        break;
                    case MemberCouponType.GIFT:
                        {
                            bool isGo = false;
                            //1、先判断是否已经完成
                            if ((this._orderObject.OrderType == OrderType.电话外卖 && this._orderObject.OrderStatus == OrderStatus.等待付款) || this._orderObject.OrderStatus == OrderStatus.已完成)
                            {
                                this.DestoryOrderObject(true);
                            }
                            //判断订单号是否正常
                            if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                            {
                                //尝试重新获取一次单号
                                var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                                if (ticket.Item1)
                                {
                                    this._orderObject.TradeNo = ticket.Item3;
                                }

                                //重新判断是否获取到单号
                                if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                                {
                                    //是否提醒收银员
                                    var isNofity = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_TICKET_NO_NOFITY, true);
                                    //是否采用本机单号
                                    var isLocalTicketNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_LOCAL_TICKET_NO, false);

                                    string notifyMessage = "获取全局单号失败,收银参数禁止使用本机单号,请重新操作";
                                    if (isNofity)
                                    {
                                        DialogForm dialog = null;
                                        //采用本机单号
                                        if (isLocalTicketNo)
                                        {
                                            notifyMessage = "获取全局单号失败,采用本机单号可能出现重复,是否继续?";
                                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                                        }
                                        else
                                        {
                                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.OK);
                                        }
                                        //操作员选择了 是
                                        if (DialogResult.Yes == dialog.ShowDialog())
                                        {
                                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                                            isGo = true;
                                        }
                                        else
                                        {
                                            isGo = false;
                                        }
                                    }
                                    else
                                    {
                                        if (isLocalTicketNo)
                                        {
                                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                                            isGo = true;
                                        }
                                        else
                                        {
                                            isGo = false;

                                            this.ShowToastNotify(this, "获取全局单号失败,设置禁止使用本机单号,请重试");
                                        }
                                    }

                                }
                                else
                                {
                                    isGo = true;
                                }
                            }
                            else
                            {
                                isGo = true;
                            }
                            if (!isGo)
                            {
                                return;
                            }
                            prom.Type = PromotionType.电子兑换券;
                            var gift = JsonUtils.Deserialize<List<CouponProductGift>>(data.Gift);
                            bool ishavProduct = false;
                            foreach (CouponProductGift productGift in gift)
                            {
                                try
                                {
                                    //筛选商品
                                    var lists = Global.Product._productList;
                                    var selectProduct = new List<ProductExt>();
                                    selectProduct = lists.FindAll(x => x.Id.Contains(productGift.ProductId));
                                    //筛选规格
                                    var specLists = Global.ProductSpec._productSpecList;
                                    var selectSpec = new List<ProductSpec>();
                                    selectSpec = specLists.FindAll(x => (x.Id.Contains(productGift.SpecId) && x.ProductId.Contains(productGift.ProductId)));
                                    //selectProduct = lists.FindAll(x => (!string.IsNullOrEmpty(x.SpecId) && x.SpecId.Contains(productGift.SpecId)));
                                    if (selectProduct != null && selectProduct.Count > 0 && selectSpec != null && selectSpec.Count > 0)
                                    {
                                        product = selectProduct[0];
                                        var productSpec = selectSpec[0];
                                        product.SpecId = productSpec.Id;
                                        product.SpecName = productSpec.Name;
                                        product.Price = productSpec.Price;
                                        product.MemberPrice = productSpec.MemberPrice;
                                        product.MinPrice = productSpec.MinPrice;
                                        //如果商品存在,就进行商品的添加
                                        newOrderItem = BusinessUtils.Instance.NewOrderItem(_orderObject, product);
                                        newOrderItem.Quantity = productGift.Num;

                                        var reduceCost = newOrderItem.Price * newOrderItem.Quantity;//优惠总金额
                                        prom.DiscountAmount = reduceCost;
                                        ishavProduct = true;
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    LOGGER.Error(ex, "加载商品信息异常");
                                }
                            }
                            if (!ishavProduct)
                            {
                                var confirm = new DialogForm("优惠券不可用提示", "门店没有对应的单品,无法使用", MessageBoxIcon.Error, MessageBoxButtons.OK);
                                confirm.TopLevel = true;
                                confirm.ShowDialog();
                                return;
                            }
                        }
                        break;
                    case MemberCouponType.PRODUCT:
                        {
                            bool isGo = false;
                            //1、先判断是否已经完成
                            if ((this._orderObject.OrderType == OrderType.电话外卖 && this._orderObject.OrderStatus == OrderStatus.等待付款) || this._orderObject.OrderStatus == OrderStatus.已完成)
                            {
                                this.DestoryOrderObject(true);
                            }
                            //判断订单号是否正常
                            if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                            {
                                //尝试重新获取一次单号
                                var ticket = OrderUtils.Instance.GenerateTicketNoEx();
                                if (ticket.Item1)
                                {
                                    this._orderObject.TradeNo = ticket.Item3;
                                }

                                //重新判断是否获取到单号
                                if (string.IsNullOrEmpty(this._orderObject.TradeNo))
                                {
                                    //是否提醒收银员
                                    var isNofity = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_TICKET_NO_NOFITY, true);
                                    //是否采用本机单号
                                    var isLocalTicketNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_LOCAL_TICKET_NO, false);

                                    string notifyMessage = "获取全局单号失败,收银参数禁止使用本机单号,请重新操作";
                                    if (isNofity)
                                    {
                                        DialogForm dialog = null;
                                        //采用本机单号
                                        if (isLocalTicketNo)
                                        {
                                            notifyMessage = "获取全局单号失败,采用本机单号可能出现重复,是否继续?";
                                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                                        }
                                        else
                                        {
                                            dialog = new DialogForm("提示信息", notifyMessage, MessageBoxIcon.Warning, MessageBoxButtons.OK);
                                        }
                                        //操作员选择了 是
                                        if (DialogResult.Yes == dialog.ShowDialog())
                                        {
                                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                                            isGo = true;
                                        }
                                        else
                                        {
                                            isGo = false;
                                        }
                                    }
                                    else
                                    {
                                        if (isLocalTicketNo)
                                        {
                                            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

                                            isGo = true;
                                        }
                                        else
                                        {
                                            isGo = false;

                                            this.ShowToastNotify(this, "获取全局单号失败,设置禁止使用本机单号,请重试");
                                        }
                                    }

                                }
                                else
                                {
                                    isGo = true;
                                }
                            }
                            else
                            {
                                isGo = true;
                            }
                            if (!isGo)
                            {
                                return;
                            }
                            prom.Type = PromotionType.电子商品券;
                            var gift = JsonUtils.Deserialize<List<CouponProductGift>>(data.Gift);
                            bool ishavProduct = false;
                            foreach (CouponProductGift productGift in gift)
                            {
                                try
                                {
                                    //筛选商品
                                    var lists = Global.Product._productList;
                                    var selectProduct = new List<ProductExt>();
                                    selectProduct = lists.FindAll(x => x.Id.Contains(productGift.ProductId));
                                    //筛选规格
                                    var specLists = Global.ProductSpec._productSpecList;
                                    var selectSpec = new List<ProductSpec>();
                                    selectSpec = specLists.FindAll(x => (x.Id.Contains(productGift.SpecId) && x.ProductId.Contains(productGift.ProductId)));
                                    //selectProduct = lists.FindAll(x => (!string.IsNullOrEmpty(x.SpecId) && x.SpecId.Contains(productGift.SpecId)));
                                    if (selectProduct != null && selectProduct.Count > 0 && selectSpec != null && selectSpec.Count > 0)
                                    {
                                        product = selectProduct[0];
                                        var productSpec = selectSpec[0];
                                        product.SpecId = productSpec.Id;
                                        product.SpecName = productSpec.Name;
                                        product.Price = productSpec.Price;
                                        product.MemberPrice = productSpec.MemberPrice;
                                        product.MinPrice = productSpec.MinPrice;
                                        //如果商品存在,就进行商品的添加
                                        newOrderItem = BusinessUtils.Instance.NewOrderItem(_orderObject, product);
                                        newOrderItem.Quantity = 1;
                                        //单品券优惠方式1-折扣，2-固定金额
                                        decimal reduceCost = 0.00M;
                                        if (data.GrantType == 1)
                                        {
                                            decimal discount = data.Discount;//折扣率
                                            reduceCost = newOrderItem.Price * ((10 - discount) / 10) * newOrderItem.Quantity;//优惠总金额
                                        }
                                        else if (data.GrantType == 2)
                                        {
                                            decimal pReduceCost = data.ReduceCost / 100M;//优惠金额
                                            if (pReduceCost >= newOrderItem.Price)
                                            {
                                                pReduceCost = newOrderItem.Price;
                                            }
                                            reduceCost = pReduceCost * newOrderItem.Quantity;//优惠总金额
                                        }
                                        prom.DiscountAmount = reduceCost;
                                        ishavProduct = true;
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    LOGGER.Error(ex, "加载商品信息异常");
                                }
                            }
                            if (!ishavProduct)
                            {
                                var confirm = new DialogForm("优惠券不可用提示", "门店没有对应的单品,无法使用", MessageBoxIcon.Error, MessageBoxButtons.OK);
                                confirm.TopLevel = true;
                                confirm.ShowDialog();
                                return;
                            }
                        }
                        break;
                }
                if (prom.DiscountAmount > 0)
                {
                    if (prom.Type == PromotionType.电子兑换券)
                    {
                        prom.IsOrder = false;

                        //添加沽清业务规则
                        SaleClear saleClear = null;
                        if (SaleClearUtils.Instance.Maps.ContainsKey(product.Id))
                        {
                            saleClear = SaleClearUtils.Instance.Maps[product.Id];
                        }
                        //是否参与沽清
                        bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                        if (isSaleClear && saleClear.Quantity <= 0)
                        {
                            this.ShowToastNotify(this, "已经销售完了!");

                            return;
                        }
                        AddGridRowEx(product, newOrderItem, false, saleClear);
                        BusinessUtils.Instance.OrderItemProductGift(this._orderObject, data.CouponId, data.Code, data.Title, newOrderItem);
                    }
                    else
                    {
                        prom.IsOrder = true;
                        prom.PromotionId = data.Code;
                        prom.PromotionDesc = data.Title;
                        prom.CouponId = data.CouponId;
                        BusinessUtils.Instance.ApplyOrderPromotion(_orderObject, prom);
                    }

                    UpdateGrid();

                    RefreshUi();

                    data.ErrorType = (int)MemberCouponStatus.使用中;
                    data.RealMoney = prom.DiscountAmount;
                    MsgEvent.Send(Constant.MEMBERCOUPON_CHANGE_NOTIFY, new Tuple<ElectronCoupon, bool>(data, true));

                    this.ShowToastNotify(this, string.Format("成功使用<{0}>,优惠<{1}>元", data.Title, prom.DiscountAmount), 3000);
                }
                else
                {
                    var confirm = new DialogForm("优惠券不可用提示", "可优惠金额为零，不能使用！", MessageBoxIcon.Error, MessageBoxButtons.OK);
                    confirm.TopLevel = true;
                    confirm.ShowDialog();
                }
            }
            else if (status == MemberCouponStatus.使用中)
            {
                //取消使用的优惠
                if (MemberCouponType.GIFT == data.CardType)
                {
                    OrderItem orderItem = null;
                    foreach (var item in _orderObject.Items)
                    {
                        List<PromotionItem> pro = item.Promotions.FindAll(x => x.PlanNo == data.Code);
                        if (pro != null && pro.Count > 0)
                        {
                            orderItem = item;
                            break;
                        }

                    }
                    if (orderItem != null)
                    {
                        DoRemoveOrderItem(orderItem);
                    }
                }
                else
                {
                    PromotionUtils.Remove(_orderObject, data.Code);
                }
                //如果是兑换券删掉当前兑换记录
                data.ErrorType = (int)MemberCouponStatus.可用;

                MsgEvent.Send(Constant.MEMBERCOUPON_CHANGE_NOTIFY, new Tuple<ElectronCoupon, bool>(data, false));
                //如果会员兑换券取消完毕
                var skipNoMoney = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_CARDPAYSKIPNOMONEY, "0");
                if (!BusinessUtils.Instance.HavMemberPromotionCoup(this._orderObject) && this._orderObject.Member.CurrentCard.AvailableAmount <= 0 && "1".Equals(skipNoMoney))
                {
                    //删除会员卡,删除会员卡优惠
                    this._orderObject.Member = null;
                    //会员卡号、姓名
                    this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), string.Empty);
                    //会员姓名
                    //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), string.Empty);
                    //会员余额
                    this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), string.Empty);
                    //会员积分
                    this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), string.Empty);

                    //取消会员优惠
                    BusinessUtils.Instance.RemoveMemberPromotion(_orderObject);

                    //关闭会员优惠提醒
                    MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, 0));
                }
                UpdateGrid();

                RefreshUi();
            }
        }

        private DialogResult SetDeskNo()
        {
            var form = new DeskNoForm(this._orderObject);
            form.AcceptButtonClick += (o, args) =>
            {
                var desk = args.Data as Tuple<string, string, string>;
                this._orderObject.TableNo = desk.Item1;
                this._orderObject.TableName = desk.Item2;
                this._orderObject.Ext1 = desk.Item3;
                if (this._orderObject.TableNo != null)
                {
                    //显示桌号
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.桌号.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.桌号, MenuTileNotifyType.数量, _orderObject.TableName) });
                }
            };
            return form.ShowDialog(this);
        }



        private void OnCashValueChanged(object sender, EnterEventArg e)
        {
            if (this._orderObject.OrderStatus == OrderStatus.已完成)
            {
                return;
            }

            this.lblOddChange.Text = string.Format(LangProxy.ToLang( this.lblOddChange.Tag.ToString()), "0");
            if (this._orderObject != null)
            {
                //计算抹零金额
                decimal malingAmount = OrderUtils.MalingAmount(this._orderObject.ReceivableAmount, null);

                //待收款项
                var receivable = (this._orderObject.ReceivableAmount - malingAmount - this._orderObject.ReceivedAmount);

                //计算找零
                var change = txtCash.DecimalValue - receivable;

                this.lblOddChange.Text = string.Format(LangProxy.ToLang(this.lblOddChange.Tag.ToString()), change.ToString());

                this._orderObject.ChangeAmount = change;

                //客显 应收不等录入金额时显示收款
                var cash = StringUtils.GetDecimal(this.txtCash.Text);
                if (this._orderObject.ReceivableAmount != cash)
                {
                    GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Recive, cash.ToString("f2"));
                }
            }
        }

        private void ProcessSuit(object sender, List<OrderItem> rows, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var autoSelectSuit = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_AUTO_SELECT_SUIT, false);

            //sender为null，为点击套餐，默认打开换菜
            if (sender == null || autoSelectSuit)
            {
                var dialogForm = new SuitDialogForm(rows, permissionCode, authz);
                dialogForm.AcceptButtonClick += (o, args) =>
                {

                    var item = args.Data as OrderItem;


                    //刷新购物车
                    this.UpdateGridRow(item);

                    //查找套餐主菜信息
                    var master = rows.ToList().Find(x => x.RowState == OrderRowState.套餐主);

                    //换菜清空该行所有的促销，暂时忘了为什么清空促销了，先屏蔽
                    //master.Promotions = new List<PromotionItem>();
                    //master.DiscountPrice = this._orderItem.Price;

                    var details = rows.ToList().FindAll(x => x.RowState == OrderRowState.套餐明);

                    master.Price = master.SalePrice + details.Sum(x => x.SuitAddPrice);

                    master.MemberPrice = master.MemberSalePrice + details.Sum(x => x.SuitAddPrice);

                    master.DiscountPrice = master.Price;

                    this.UpdateGridRow(master);

                    //套餐主特殊处理
                    UpdateSuitMain(this._orderItem);

                    //刷新界面元素
                    this.RefreshUiEx();

                    //分摊道菜优惠
                    PromotionUtils.CalculateSuitShare(this._orderObject, rows.ToList());

                };

                dialogForm.CancelButtonClick += (o, args) => { };

                TransparentForm trans = new TransparentForm(this, 0.01, dialogForm);
                trans.Show(this);
            }
            else
            {
                this.OrderItemSuit(sender, rows, permissionCode);
            }
        }

        private void ProcessSpec(object sender, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var autoSelectSpec = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_AUTO_SELECT_SPEC, true);

            if (autoSelectSpec)
            {
                var dialogForm = new SpecDialogForm(orderItem, permissionCode, authz);
                dialogForm.AcceptButtonClick += (o, args) =>
                {

                    //会员价处理
                    //BusinessUtils.Instance.AddMemberPromotion(_orderObject, orderItem);

                    //清空该行所有的促销
                    var list = BusinessUtils.Instance.RemoveOrderItemPromotion(this._orderObject, this._orderItem);

                    foreach (var item in list)
                    {
                        //刷新购物车
                        this.UpdateGridRow(item);
                    }

                    //刷新界面元素
                    this.RefreshUi();
                };

                dialogForm.CancelButtonClick += (o, args) => { };

                TransparentForm trans = new TransparentForm(this, dialogForm);
                trans.Show(this);
            }
            else
            {
                this.OrderItemSpec(sender, orderItem, permissionCode);
            }
        }


        private void ProcessFlavor(object sender, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var autoDialog = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_AUTO_SELECT_FLAVOR, true);
            if (autoDialog)
            {
                var dialogForm = new FlavorDialogForm(orderItem, permissionCode, authz);
                dialogForm.AcceptButtonClick += (o, args) =>
                {

                    //套餐主特殊处理
                    UpdateSuitMain(orderItem);

                    //刷新购物车
                    this.UpdateGridRow();

                    //刷新界面元素
                    this.RefreshUi();
                };

                dialogForm.CancelButtonClick += (o, args) => { };

                TransparentForm trans = new TransparentForm(this, dialogForm);
                trans.Show(this);
            }
            else
            {
                this.OrderItemFlavor(sender, orderItem, permissionCode);
            }
        }

        /// <summary>
        /// 免单
        /// </summary>
        /// <param name="module"></param>
        /// <param name="orderObject"></param>
        /// <param name="authz"></param>
        private void ProcessMd(ModuleMenu module, OrderObject orderObject, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            bool isGo = true;
            string message = string.Empty;
            //有整单优惠，禁止操作
            if (isGo && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
            {
                isGo = false;
                message = "享受整单优惠，不允许操作";
            }
            foreach (var orderItem in _orderObject.Items)
            {
                if (isGo && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                {
                    isGo = false;
                    message = "享受过优惠，不允许操作";
                    break;
                }
            }

            if (isGo)
            {
                //当前收银员的最高折扣率
                decimal maxFreeAmount = Global.Instance.Worker.MaxFreeAmount;
                if (authz != null)
                {
                    maxFreeAmount = authz.Item1;
                }
                //可免单金额
                var discountAmount = PromotionUtils.GetValidPromItemsAmount(orderObject);

                //当前收银员的最高折扣
                if (isGo && discountAmount > maxFreeAmount)
                {
                    isGo = false;

                    //折扣权限授权
                    var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                    authForm.ExpectValidate(module.PermissionCode, decimal.MaxValue, discountAmount);

                    authForm.AcceptButtonClick += (o, args) =>
                    {

                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                        {
                            //授权人权限信息
                            var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                            this.DoMd(discountAmount);
                        }
                    };
                    authForm.CancelButtonClick += (o, args) => { };
                    TransparentForm trans = new TransparentForm(this, authForm);
                    trans.Show(this);
                }
                else
                {
                    this.DoMd(discountAmount);
                }
            }
            else
            {
                this.ShowToastNotify(this, message);
            }
        }

        private void DoMd(decimal discountAmount)
        {
            BusinessUtils.Instance.OrderMd(_orderObject, discountAmount);

            StoreBusinessUtils.SaveOperationLog("305", "单号:" + _orderObject.TradeNo);

            this.UpdateGrid();

            //刷新界面元素
            this.RefreshUi();
        }

        private void ProcessQuickDiscount(ModuleMenu module, OrderObject orderObject, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            bool isGo = true;
            var disRate = StringUtils.GetDecimal(module.KeyData);
            decimal v = (disRate / Convert.ToDecimal(100.0));
            decimal.TryParse(v.ToString("0.##"), out v);
            if (v < 0 || v >= 1)
            {
                this.ShowToastNotify(this, string.Format("操作失败！折扣[{0}]非法!", disRate));
            }

            //当前收银员的最高折扣率
            decimal maxDiscountRate = Global.Instance.Worker.MaxDiscountRate;
            if (authz != null)
            {
                maxDiscountRate = authz.Item1;
            }
            //当前收银员的最高折扣
            if (isGo && v < maxDiscountRate)
            {
                isGo = false;

                //折扣权限授权
                var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                authForm.ExpectValidate(module.PermissionCode, v);

                authForm.AcceptButtonClick += (o, args) =>
                {

                    if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                    {
                        //授权人权限信息
                        var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                        this.DoQuickDiscount(module, v);
                    }
                };
                authForm.CancelButtonClick += (o, args) => { };
                TransparentForm trans = new TransparentForm(this, authForm);
                trans.Show(this);
            }
            else
            {
                this.DoQuickDiscount(module, v);
            }

        }

        private void DoQuickDiscount(ModuleMenu module, decimal descountRate)
        {
            ModuleKeyCode _keyCode = ModuleKeyCode.None;
            Enum.TryParse<ModuleKeyCode>(module.KeyCode, out _keyCode);
            if (_keyCode == ModuleKeyCode.单品定率折扣)
            {
                //单品定率折扣
                var promotion = new PromotionItem();
                //标识
                promotion.Id = IdWorkerUtils.Instance.NextId();
                //租户ID
                promotion.TenantId = this._orderItem.TenantId;
                //订单ID
                promotion.OrderId = this._orderItem.OrderId;
                //订单编号
                promotion.TradeNo = this._orderItem.TradeNo;
                //单品编号
                promotion.ItemId = this._orderItem.Id;
                //类型
                promotion.PromotionType = PromotionType.折扣;
                //方案
                promotion.PlanName = module.Name;
                //折扣率
                promotion.DiscountRate = descountRate;

                //是否启用
                promotion.Enabled = false;

                //重新计算优惠
                PromotionUtils.Calculate(this._orderObject, this._orderItem, promotion);

                //套餐道菜分摊
                PromotionUtils.CalculateSuitShare(this._orderObject, this._orderItem);

                _orderItem.Action = "单品定率折扣操作";
            }
            else if (_keyCode == ModuleKeyCode.整单定率折扣)
            {
                //整单定率折扣
                var promotion = new PromotionOrder();
                //标识
                promotion.Id = IdWorkerUtils.Instance.NextId();
                //租户ID
                promotion.TenantId = this._orderObject.TenantId;
                //订单ID
                promotion.OrderId = this._orderObject.Id;
                //订单编号
                promotion.TradeNo = this._orderObject.TradeNo;
                //单品编号
                promotion.ItemId = string.Empty;
                //类型
                promotion.PromotionType = PromotionType.整单折扣;
                //方案
                promotion.PlanName = module.Name;
                //折扣率
                promotion.DiscountRate = descountRate;

                //优惠前金额
                promotion.Amount = this._orderObject.Amount;
                //优惠金额
                promotion.DiscountAmount = OrderUtils.ToRound(this._orderObject.Amount * (1 - descountRate));
                //整单折扣后的金额
                promotion.ReceivableAmount = this._orderObject.Amount - promotion.DiscountAmount;

                //是否启用
                promotion.Enabled = false;

                //重新计算优惠
                PromotionUtils.Calculate(_orderObject, promotion);

            }

            //更新表格全部
            UpdateGrid();

            //刷新界面元素
            this.RefreshUi();
        }

        /// <summary>
        /// 整单立减
        /// </summary>
        /// <param name="module"></param>
        /// <param name="orderObject"></param>
        /// <param name="authz"></param>
        private void ProcessOrderLj(ModuleMenu module, OrderObject orderObject, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            //最低售价销售或者权限不足时提示,收银员确认是否继续
            bool isGo = true;

            var discountAmount = StringUtils.GetDecimal(module.KeyData);
            if (discountAmount == 0)
            {
                this.ShowToastNotify(this, string.Format("操作失败！优惠金额[{0}]非法!", discountAmount));
                isGo = false;
            }
            //正负转换，立减1元输入的是-1，加1元输入的是1。so
            discountAmount *= -1;

            if (isGo)
            {
                if (discountAmount > 0)
                {
                    //当前收银员的最高折扣率
                    decimal maxDiscountRate = Global.Instance.Worker.MaxDiscountRate;
                    if (authz != null)
                    {
                        maxDiscountRate = authz.Item1;
                    }
                    //当前售价的最高优惠
                    decimal maxDiscountAmount = orderObject.Amount * (1 - maxDiscountRate);

                    if (isGo && discountAmount > maxDiscountAmount)
                    {
                        isGo = false;

                        //折扣权限授权
                        var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                        var expectDiscount = OrderUtils.ToRound(1 - (discountAmount / orderObject.Amount));

                        authForm.ExpectValidate(module.PermissionCode, expectDiscount);

                        authForm.AcceptButtonClick += (o, args) =>
                        {

                            if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                            {
                                //授权人权限信息
                                var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                this.DoOrderLj(module.Name, discountAmount);

                            }
                        };
                        authForm.CancelButtonClick += (o, args) => { };
                        TransparentForm trans = new TransparentForm(this, authForm);
                        trans.Show(this);
                    }
                    else
                    {
                        this.DoOrderLj(module.Name, discountAmount);
                    }
                }
                else
                {
                    //增加金额直接通过
                    this.DoOrderLj(module.Name, discountAmount);
                }
            }
        }

        private void DoOrderLj(string planName, decimal discountAmount)
        {
            //整单定额优惠
            var promotion = new PromotionOrder();
            //标识
            promotion.Id = IdWorkerUtils.Instance.NextId();
            //租户ID
            promotion.TenantId = this._orderItem.TenantId;
            //订单ID
            promotion.OrderId = this._orderItem.OrderId;
            //订单编号
            promotion.TradeNo = this._orderItem.TradeNo;
            //单品编号
            promotion.ItemId = string.Empty;
            //类型
            promotion.PromotionType = PromotionType.整单立减;
            //方案名称
            promotion.PlanName = planName;
            //优惠前的金额
            promotion.Amount = this._orderObject.Amount;
            //优惠额
            promotion.DiscountAmount = discountAmount;
            //优惠后的金额
            promotion.ReceivableAmount = OrderUtils.ToRound(promotion.Amount - promotion.DiscountAmount);
            //优惠率
            promotion.DiscountRate = OrderUtils.ToRound(promotion.ReceivableAmount / promotion.Amount);
            //优惠生效
            promotion.Enabled = true;

            StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo);

            PromotionUtils.Calculate(this._orderObject, promotion);

            //更新表格全部
            UpdateGrid();

            //刷新界面元素
            this.RefreshUi();
        }

        private void UpdateGdNum()
        {
            this.BeginInvoke(new MethodInvoker(() =>
            {
                using (var db = Global.Instance.OpenDataBase)
                {
                    var table = db.Query<OrderTemp>("where storeId = @0", Global.Instance.Worker.StoreId);
                    int count = table.Count();
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.取单.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.取单, MenuTileNotifyType.数量, count.ToString()) });
                }
            }));

        }

        private void ProcessQd()
        {
            var form = new QdForm();
            form.AcceptButtonClick += (o, args) =>
            {
                if (args.Data != null)
                {
                    var order = JsonUtils.Deserialize<OrderObject>(args.Data.ToString());
                    if (order != null)
                    {
                        if (this._orderObject.OrderStatus != OrderStatus.已完成 && this._orderObject.TotalQuantity > 0)
                        {
                            //当前订单有未结账商品，自动挂单
                            ProcessGd(false, "上一单已自动挂单！");
                        }

                        DestoryOrderObject(true, false);

                        //更改当前订单
                        this._orderObject = order;
                        //更改当前班次
                        this._orderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;
                        this._orderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;
                        //更改销售时间为今天
                        this._orderObject.SaleDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                        //重新绑定变更
                        this._orderObject.Maps.CollectionChanged += OrderItemCollectionChanged;

                        //会员
                        if (this._orderObject.Member != null)
                        {
                            //修改会员卡号显示
                            string _cardNo = this._orderObject.Member.CurrentCard.CardNo;
                            string _mask = _cardNo.Length > 12 ? _cardNo.Substring(6, 7) : "";

                            //会员卡号
                            this.lblMemberCardNo.Text = string.Format(LangProxy.ToLang(this.lblMemberCardNo.Tag.ToString()), _cardNo.Replace(_mask, "***"));
                            //会员姓名
                            //this.lblMemberName.Text = string.Format(this.lblMemberName.Tag.ToString(), this._orderObject.Member.Name);
                            //会员余额
                            this.lblMemberAmount.Text = string.Format(LangProxy.ToLang(this.lblMemberAmount.Tag.ToString()), this._orderObject.Member.CurrentCard.AvailableAmount);
                            //会员积分
                            this.lblMemberPoint.Text = string.Format(LangProxy.ToLang(this.lblMemberPoint.Tag.ToString()), this._orderObject.Member.CurrentCard.TotalPoint);
                            //刷新优惠券信息
                            Task.Factory.StartNew(() =>
                        {
                            //查询会员优惠券，有则提示收银员当前会员有优惠券
                            var resp = CardUtils.QueryElecCoupon("mobile", _orderObject.Member.Mobile, "0", 1);
                            if (resp.Item1)
                            {
                                var list = resp.Item3;
                                if (list != null && list.Count > 0)
                                {
                                    this.Invoke(new Action(() =>
                                {
                                    MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, list.Count));
                                    //this.ShowToastNotify(this, "会员优惠提示:该会员有可用优惠券哦!");
                                }));
                                }
                            }
                        });
                        }
                        //刷新促销列表
                        RefreshUi();
                        //更新表格全部
                        ShowAllOrderItem(this._orderObject);
                        //刷新整个点单列表
                        UpdateGrid();
                        //刷新界面元素
                        this.RefreshUiEx();

                        if (this._orderObject.Promotions != null)
                        {
                            foreach (PromotionOrder promotionOrder in this._orderObject.Promotions)
                            {
                                var data = new PromotionEntity();
                                data.PromotionId = promotionOrder.PlanNo;
                                data.Type = promotionOrder.PromotionType;
                                data.PromotionDesc = promotionOrder.PlanName;
                                data.DiscountAmount = promotionOrder.DiscountAmount;
                                MsgEvent.Send(Constant.ORDERPROMOTION_CHANGED_NOTIFY, new Tuple<PromotionEntity, bool>(data, true));
                            }

                        }
                        //显示桌号
                        MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.桌号.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.桌号, MenuTileNotifyType.数量, _orderObject.TableName) });

                        //删除当前取出的挂单数据
                        lock (Global.Instance.SyncLock)
                        {
                            using (var db = Global.Instance.OpenDataBase)
                            {
                                db.Delete<OrderTemp>("where orderId = @0", this._orderObject.Id);
                            }
                        }

                        //更新挂单数量
                        UpdateGdNum();

                        //副屏通知
                        if (Global.Instance.EnableVice)
                        {
                            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.BATCHADDORDERITEM, _orderObject));
                        }

                    }
                }
            };
            form.CancelButtonClick += (o, args) => { };
            form.StartPosition = FormStartPosition.CenterScreen;
            form.BringToFront();
            form.Show();
        }

        private void ProcessGd(bool createNew, string notifyMsg)
        {
            //挂单取单按钮合一
            if (this._orderObject.Items.Count <= 0 || this._orderObject.OrderStatus == OrderStatus.已完成)
            {
                this.ProcessQd();
                return;
            }
            //不符合取单条件进行挂单
            if (string.IsNullOrEmpty(this._orderObject.OrderNo))
            {
                string orderNo = string.Empty;
                var order = OrderUtils.Instance.GenerateOrderNoEx();
                if (order.Item1)
                {
                    orderNo = order.Item3;
                }
                else
                {
                    LOGGER.Info("**挂单采用本机序号**");

                    orderNo = OrderUtils.Instance.GenerateOrderNo();
                }
                //订单序号
                this._orderObject.OrderNo = orderNo;
            }
            var saveResult = OrderUtils.Instance.SaveOrderTemp(this._orderObject);
            if (!saveResult.Item1)
            {
                this.ShowToastNotify(this, "挂单失败！");
            }
            else
            {
                //挂单成功
                this.ShowToastNotify(this, notifyMsg ?? "挂单成功！");

                UpdateGdNum();

                var order = ObjectUtils.Copy(this._orderObject);
                Task.Factory.StartNew(new Action(() =>
                {
                    var orderTemp = saveResult.Item2;
                    var isUpdate = false;
                    var gdChuDa = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_GUADAN_CHUDA, false);
                    if (gdChuDa)
                    {
                        //厨打小票打印
                        ChuDaHelper.KitchenPrinter(order, false);
                        isUpdate = true;
                    }

                    var gdChudaLabel = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_GUADAN_CHUDA_LABEL, false);
                    if (gdChudaLabel)
                    {
                        //厨打标签
                        ChuDaHelper.KitchenLabelPrinter(order, false);
                        isUpdate = true;
                    }

                    var gdChuPin = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_GUADAN_CHUPIN, false);
                    if (gdChuPin)
                    {
                        //出品小票打印
                        ChuDaHelper.MadePrinter(order, false);
                        isUpdate = true;
                    }

                    var gdLabel = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_LABEL_PRINT_ONGD, false);
                    if (gdLabel)
                    {
                        //挂单打印标签
                        LabelPrintHelper.PrintOrderLabel(order, false);
                        isUpdate = true;
                    }

                    if (isUpdate)
                    {
                        orderTemp.OrderJson = JsonUtils.Serialize(order);
                        lock (Global.Instance.SyncLock)
                        {
                            using (var db = Global.Instance.OpenDataBase)
                            {
                                using (var trans = db.GetTransaction())
                                {
                                    db.Update(orderTemp);

                                    trans.Complete();
                                }
                            }
                        }
                    }

                }));


                if (createNew)
                {
                    this.DestoryOrderObject(createNew);
                }

                //刷新界面
                this.RefreshUi();
            }

        }

        private void ProcessLj(ModuleMenu module, OrderObject orderObject, OrderItem orderItem, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            //最低售价销售或者权限不足时提示,收银员确认是否继续
            bool isGo = true;
            //优惠金额
            var discountAmount = StringUtils.GetDecimal(module.KeyData);
            if (discountAmount == 0)
            {
                this.ShowToastNotify(this, string.Format("操作失败！优惠金额[{0}]非法!", discountAmount));
                isGo = false;
            }
            //正负转换，立减1元输入的是-1，加1元输入的是1。so
            discountAmount *= (-1 * orderItem.Quantity);


            if (isGo && discountAmount > 0)
            {
                //当前收银员的最高折扣率
                decimal maxDiscountRate = Global.Instance.Worker.MaxDiscountRate;
                if (authz != null)
                {
                    maxDiscountRate = authz.Item1;
                }
                //当前售价的最高优惠
                decimal maxDiscountAmount = this._orderItem.Quantity * this._orderItem.Price * (1 - maxDiscountRate);

                if (isGo && discountAmount > maxDiscountAmount)
                {
                    isGo = false;

                    //折扣权限授权
                    var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                    var expectDiscount = OrderUtils.ToRound(1 - (discountAmount / orderItem.Amount));

                    authForm.ExpectValidate(module.PermissionCode, expectDiscount);

                    authForm.AcceptButtonClick += (o, args) =>
                    {

                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                        {
                            //授权人权限信息
                            var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                            this.DoLj(module.Name, discountAmount);
                        }
                    };
                    authForm.CancelButtonClick += (o, args) => { };
                    TransparentForm trans = new TransparentForm(this, authForm);
                    trans.Show(this);
                }
                else
                {
                    this.DoLj(module.Name, discountAmount);
                }
            }
            else
            {
                //增加金额直接通过
                this.DoLj(module.Name, discountAmount);
            }



        }

        /// <summary>
        /// 整单立减
        /// </summary>
        /// <param name="module"></param>
        /// <param name="orderObject"></param>
        /// <param name="authz"></param>
        private void ProcessOrderLjAmount(ModuleMenu module, decimal ljAmount, OrderObject orderObject, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            //最低售价销售或者权限不足时提示,收银员确认是否继续
            bool isGo = true;

            var discountAmount = ljAmount;
            if (discountAmount == 0)
            {
                this.ShowToastNotify(this, string.Format("操作失败！优惠金额[{0}]非法!", discountAmount));
                isGo = false;
            }
            //正负转换，立减1元输入的是-1，加1元输入的是1。so
            discountAmount *= -1;

            if (isGo)
            {
                if (discountAmount > 0)
                {
                    //当前收银员的最高折扣率
                    decimal maxDiscountRate = Global.Instance.Worker.MaxDiscountRate;
                    if (authz != null)
                    {
                        maxDiscountRate = authz.Item1;
                    }
                    //当前售价的最高优惠
                    decimal maxDiscountAmount = orderObject.Amount * (1 - maxDiscountRate);

                    if (isGo && discountAmount > maxDiscountAmount)
                    {
                        isGo = false;

                        //折扣权限授权
                        var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                        var expectDiscount = OrderUtils.ToRound(1 - (discountAmount / orderObject.Amount));

                        authForm.ExpectValidate(module.PermissionCode, expectDiscount);

                        authForm.AcceptButtonClick += (o, args) =>
                        {

                            if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                            {
                                //授权人权限信息
                                var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                                this.DoOrderLj(module.Name, discountAmount);

                            }
                        };
                        authForm.CancelButtonClick += (o, args) => { };
                        TransparentForm trans = new TransparentForm(this, authForm);
                        trans.Show(this);
                    }
                    else
                    {
                        this.DoOrderLj(module.Name, discountAmount);
                    }
                }
                else
                {
                    //增加金额直接通过
                    this.DoOrderLj(module.Name, discountAmount);
                }
            }
        }
        private void ProcessLjAmount(ModuleMenu module, decimal ljAmount, OrderObject orderObject, OrderItem orderItem, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            //最低售价销售或者权限不足时提示,收银员确认是否继续
            bool isGo = true;
            //优惠金额
            var discountAmount = ljAmount;
            if (discountAmount == 0)
            {
                this.ShowToastNotify(this, string.Format("操作失败！优惠金额[{0}]非法!", discountAmount));
                isGo = false;
            }
            //正负转换，立减1元输入的是-1，加1元输入的是1。so
            discountAmount *= (-1 * orderItem.Quantity);


            if (isGo && discountAmount > 0)
            {
                //当前收银员的最高折扣率
                decimal maxDiscountRate = Global.Instance.Worker.MaxDiscountRate;
                if (authz != null)
                {
                    maxDiscountRate = authz.Item1;
                }
                //当前售价的最高优惠
                decimal maxDiscountAmount = this._orderItem.Quantity * this._orderItem.Price * (1 - maxDiscountRate);

                if (isGo && discountAmount > maxDiscountAmount)
                {
                    isGo = false;

                    //折扣权限授权
                    var authForm = new AuthDialogForm(module.KeyCode, module.PermissionCode, this._orderObject);

                    var expectDiscount = OrderUtils.ToRound(1 - (discountAmount / orderItem.Amount));

                    authForm.ExpectValidate(module.PermissionCode, expectDiscount);

                    authForm.AcceptButtonClick += (o, args) =>
                    {

                        if (args.Data is Tuple<decimal, decimal, List<string>, Worker>)
                        {
                            //授权人权限信息
                            var tempAuthz = args.Data as Tuple<decimal, decimal, List<string>, Worker>;

                            this.DoLj(module.Name, discountAmount);
                        }
                    };
                    authForm.CancelButtonClick += (o, args) => { };
                    TransparentForm trans = new TransparentForm(this, authForm);
                    trans.Show(this);
                }
                else
                {
                    this.DoLj(module.Name, discountAmount);
                }
            }
            else
            {
                //增加金额直接通过
                this.DoLj(module.Name, discountAmount);
            }
        }

        private void DoLj(string planName, decimal discountAmount)
        {
            bool isGo = true;
            //是否低于最低售价的验证
            //最低售价下的金额
            decimal minAmount = this._orderItem.Quantity * this._orderItem.MinPrice;
            if ((this._orderItem.Amount - discountAmount) < minAmount)
            {
                //是否允许低于最低售价销售
                bool allowMinPriceSale = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ALLOW_MIN_PRICE_SALE, false);
                //允许低于最低售价
                if (isGo && allowMinPriceSale)
                {
                    //低于最低售价销售时提示
                    bool allowMinPriceSaleNofity = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_MIN_PRICE_SALE_NOTIFY, false);

                    //低于最低售价销售时提示
                    if (isGo && allowMinPriceSaleNofity)
                    {
                        var dialog = new DialogForm("销售提示信息", "您确定要低于最低售价销售?", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);
                        if (DialogResult.Cancel == dialog.ShowDialog(this))
                        {
                            isGo = false;
                        }
                    }
                }
                else
                {
                    this.ShowToastNotify(this, "不允许低于最低售价销售");
                    isGo = false;
                }
            }

            if (isGo)
            {
                //单品定额优惠
                var promotion = new PromotionItem();
                //标识
                promotion.Id = IdWorkerUtils.Instance.NextId();
                //租户ID
                promotion.TenantId = this._orderItem.TenantId;
                //订单ID
                promotion.OrderId = this._orderItem.OrderId;
                //订单编号
                promotion.TradeNo = this._orderItem.TradeNo;
                //单品编号
                promotion.ItemId = this._orderItem.Id;
                //类型
                promotion.PromotionType = PromotionType.立减;
                //方案名称
                promotion.PlanName = planName;
                //优惠额
                promotion.DiscountAmount = discountAmount;

                PromotionUtils.Calculate(this._orderObject, this._orderItem, promotion);

                StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo);

                //更新表格全部
                UpdateGrid();

                //刷新界面元素
                this.RefreshUi();
            }
        }
        private void ProcessBargain(ModuleKeyCode keyCode, OrderObject orderObject, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var dialogForm = new BargainDialogForm(keyCode, orderItem, orderObject, permissionCode, authz);
            dialogForm.AcceptButtonClick += (o, args) =>
            {
                if (args.KeyCode.Equals("order") && args.Data is PromotionOrder)
                {
                    var promotion = args.Data as PromotionOrder;

                    //重新计算优惠
                    PromotionUtils.Calculate(orderObject, promotion);

                }

                if (args.KeyCode.Equals("item") && args.Data is PromotionItem)
                {
                    var promotionItem = args.Data as PromotionItem;

                    //重新计算优惠
                    PromotionUtils.Calculate(orderObject, orderItem, promotionItem);

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(orderObject, orderItem);

                    orderItem.Action = "单品议价操作";
                }

                StoreBusinessUtils.SaveOperationLog("303", "单号:" + _orderObject.TradeNo);

                //更新表格全部
                UpdateGrid();

                //刷新界面元素
                this.RefreshUi();
            };

            dialogForm.CancelButtonClick += (o, args) => { };

            TransparentForm trans = new TransparentForm(this, dialogForm);
            trans.Show(this);
        }

        private void ProcessDiscount(ModuleKeyCode keyCode, OrderObject orderObject, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var dialogForm = new DiscountDialogForm(keyCode, orderItem, orderObject, permissionCode, authz);
            dialogForm.AcceptButtonClick += (o, args) =>
            {
                //整单折扣
                if (args.KeyCode.Equals("order") && args.Data is PromotionOrder)
                {
                    var promotion = args.Data as PromotionOrder;

                    //重新计算优惠
                    PromotionUtils.Calculate(orderObject, promotion);

                }

                //单品折扣
                if (args.KeyCode.Equals("item") && args.Data is PromotionItem)
                {
                    var promotionItem = args.Data as PromotionItem;

                    //重新计算优惠
                    PromotionUtils.Calculate(orderObject, orderItem, promotionItem);

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(orderObject, orderItem);

                    orderItem.Action = "单品折扣操作";
                }

                StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo);

                //更新表格全部
                UpdateGrid();

                //刷新界面元素
                this.RefreshUi();


            };
            dialogForm.CancelButtonClick += (o, args) => { };

            TransparentForm trans = new TransparentForm(this, dialogForm);
            trans.Show(this);
        }

        private void ProcessErect(ModuleKeyCode keyCode, ModuleMenu module, OrderObject orderObject, OrderItem orderItem, string permissionCode, Tuple<decimal, decimal, List<string>, Worker> authz = null)
        {
            var dialogForm = new ErectDialogFrom(keyCode, orderItem, orderObject, permissionCode, authz);
            dialogForm.AcceptButtonClick += (o, args) =>
            {
                if (args.KeyCode.Equals("order") && args.Data is PromotionOrder)
                {
                    var promotion = args.Data as PromotionItem;
                    //整单立减
                    this.ProcessOrderLjAmount(module, 0 - promotion.DiscountAmount, this._orderObject);
                }

                if (args.KeyCode.Equals("item") && args.Data is PromotionItem)
                {
                    var promotion = args.Data as PromotionItem;
                    //单品立减
                    this.ProcessLjAmount(module, 0 - promotion.DiscountAmount, this._orderObject, this._orderItem);
                }

                StoreBusinessUtils.SaveOperationLog("301", "单号:" + _orderObject.TradeNo);
            };

            dialogForm.CancelButtonClick += (o, args) => { };

            TransparentForm trans = new TransparentForm(this, dialogForm);
            trans.Show(this);
        }

        /// <summary>
        /// 电话外卖结账
        /// </summary>
        private void DeliveryPay()
        {
            var result = BusinessUtils.Instance.DeliveryPay(_orderObject);

            if (result.Item1)
            {
                this.DestoryOrderObject(false);
            }
            else
            {
                this.ShowToastNotify(this, result.Item2);
            }

        }

        /// <summary>
        /// 自动弹出桌号
        /// </summary>
        /// <returns></returns>
        private bool ProcessAutoDeskNo()
        {
            if (!string.IsNullOrEmpty(this._orderObject.TableNo))
            {
                //有桌号，不弹
                return true;
            }
            ///自动弹出桌号
            var autoDeskNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_CHECKAUTOOPENDESKNO, false);
            if (autoDeskNo)
            {
                var result = SetDeskNo();
                if (result == DialogResult.OK)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 现金结账
        /// </summary>
        private void QuickPay()
        {
            LOGGER.Info("操作现金结账");

            //自动弹出桌号
            if (!ProcessAutoDeskNo())
            {
                return;
            }

            //操作员输入的实收金额
            decimal inputMoney = this.txtCash.DecimalValue;

            var result = BusinessUtils.Instance.QuickPay(_orderObject, inputMoney);

            if (result.Item1)
            {
                this.DestoryOrderObject(false);
            }
            else
            {
                this.ShowToastNotify(this, result.Item2);
            }
        }

        private void OnCheckoutControlVisibleChanged(object sender, EventArgs e)
        {
            var checkout = (CheckoutControl)sender;

            //登陆工作区自动居中
            checkout.Location = new Point((this.orderPanel.Width - checkout.Width) / 2, (this.orderPanel.Height - checkout.Height) / 2);

            string info = "已结账";
            if (this._orderObject != null && this._orderObject.OrderType == OrderType.电话外卖)
            {
                info = "外卖结账";
            }
            checkout.Text = info;
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            switch (keyData)
            {

                case Keys.Right:
                    {
                        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Right);
                    }
                    break;
                case Keys.Left:
                    {
                        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Left);
                    }
                    break;
                case Keys.Up:
                    {
                        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Up);
                    }
                    break;
                case Keys.Down:
                    {
                        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Down);
                    }
                    break;
                case Keys.Enter:
                    {
                        if (isScanning)
                        {
                            SearchProduct(this.txtSearch.Text.Trim(), true);
                            isScanning = false;
                        }
                        else
                        {
                            if (this.txtSearch.Text.Trim() != null && this.txtSearch.Text.Trim().Length > 0)
                            {
                                MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Enter);
                            }
                            else
                            {
                                this.txtSearch.Focus();
                            }
                        }

                        //Task.Factory.StartNew(() =>
                        //{
                        //    Thread.Sleep(100);
                        //    this.Invoke(new Action(() =>
                        //    {
                        //        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Enter);
                        //    }));
                        //});
                    }
                    break;
            }

            return base.ProcessCmdKey(ref msg, keyData);
        }


        private DateTime dtStart = DateTime.Now;

        private bool isScanning = false;

        private void OnSearchTextChanged(object sender, EventArgs e)
        {
            var search = this.txtSearch.Text.Trim();
            if (string.IsNullOrEmpty(search))
            {
                return;
            }

            DateTime dtCurrent = DateTime.Now;
            TimeSpan ts = dtCurrent.Subtract(dtStart);
            if (ts.Milliseconds < 50)
            {
                isScanning = true;

                Console.WriteLine("扫描枪;ts:" + ts.Milliseconds.ToString() + " Text:" + this.txtSearch.Text.Trim());
            }
            else
            {
                isScanning = false;

                Console.WriteLine("手动输入;ts:" + ts.Milliseconds.ToString() + " Text:" + this.txtSearch.Text.Trim());

                SearchProduct(search, false);
            }
            dtStart = dtCurrent;
        }

        private void SearchProduct(string search, bool autoSubmit)
        {

            Task.Factory.StartNew(() =>
            {
                if (!autoSubmit)
                {
                    //手动输入时，50毫秒内非扫枪，就认为是手动输入，否则认为扫枪，取消本次查询
                    Thread.Sleep(10);

                    if (isScanning)
                    {
                        return false;
                    }
                }
                this.Invoke(new Action(() =>
                {
                    try
                    {
                        var lists = Global.Product._productList;
                        var selectProduct = new List<ProductExt>();
                        selectProduct = lists.FindAll(x => (!string.IsNullOrEmpty(x.Spell) && x.Spell.Contains(search)) || (!string.IsNullOrEmpty(x.BarCode) && x.BarCode.Contains(search)) || (!string.IsNullOrEmpty(x.No) && x.No.Contains(search)) || (!string.IsNullOrEmpty(x.AssistNo) && x.AssistNo.Contains(search)));
                        this.productControl1.PageNumber = 1;
                        this.productControl1.BindDataSource(selectProduct, KeyboardAction.Search);
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Error(ex, "加载商品信息异常");
                    }

                }));
                LOGGER.Info("搜索：{0}", autoSubmit ? "扫枪" : "手动");
                return true;

            }).ContinueWith(task =>
            {
                if (task.Result)
                {
                    this.Invoke(new Action(() =>
                    {
                        MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Search);
                        if (autoSubmit)
                        {
                            MsgEvent.Send(Constant.PRODUCT_KEYBOARD_NOTIFY, KeyboardAction.Enter);
                        }
                    }));
                }

            });
        }

        private void OnSearchCustomClick(object sender, EventArgs e)
        {
            if (SimpleKeyboard.Showing())
            {
                SimpleKeyboard.CloseKeyboard();
            }
            else
            {
                var location = this.menuControl.PointToScreen(Point.Empty);

                var size = this.menuControl.Size;

                //var action = new Action<string>((args) => {
                //    this.txtSearch.Text = (args != null ? args.ToString() : string.Empty);
                //});
                //SimpleKeyboard.ShowKeyboard(this , location , size , true, action);

                SimpleKeyboard.ShowKeyboard(this, location, size, false, null);
            }
        }
        public void InfoGuoPanDll()
        {
            var _msid = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_GUOPANMSID, "");
            var _key = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_GUOPANKEY, "");

            if (Global.Instance.Worker.TenantId.Equals("771200"))
            {
                return;
            }
            var _ParenthWnd = FindWindow(null, this.Text);

            if (string.IsNullOrEmpty(_msid) || string.IsNullOrEmpty(_key))
            {
                return;
            }

            var _data = GuoPanProxy.ApiInit(_msid, _key, _ParenthWnd.ToInt32());

            if (!_data.Item1)
            {
                this.ShowToastNotify(this, _data.Item2, 5000);
                return;
                DialogForm dialog = new DialogForm("操作提醒", "初始化果盘参数异常，是否继续请求初始化？", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);
                if (DialogResult.OK == dialog.ShowDialog(this))
                {
                    InfoGuoPanDll();
                    return;
                }
            }
        }

        [DllImport("User32.dll", EntryPoint = "FindWindow")]
        private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        protected override void DefWndProc(ref Message m)
        {
            base.DefWndProc(ref m);

            switch (m.Msg)
            {
                case 2907:
                    int _LParam = m.LParam.ToInt32();
                    if (_LParam == 0)
                    {
                        return;
                    }

                    try
                    {
                        var _id = _LParam;
                        bool openConfirm = Global.Instance.GlobalConfigBoolValue(ConfigConstant.WEIXIN_CONFIRM_PARAMETER, true);
                        if (openConfirm)
                        {
                            GuoPanProxy.AutoConfirmOrder(_id);
                        }
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Error(ex, "自动接单失败");
                    }

                    MsgEvent.Send(Constant.GuoPan_WEIXIN_UI_UPDATA, _LParam);
                    break;
                default:
                    break;
            }
        }

    }
}