using NLog;
using POSV.Card;
using POSV.Dianping;
using POSV.Entity;
using POSV.Entity.Pormotion;
using POSV.Helper;
using POSV.MessageEvent;
using POSV.StoreBusiness;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace POSV.ShoppingCart
{
    /// <summary>
    /// 订单业务运算工具类
    /// </summary>
    public class BusinessUtils
    {
        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private static object _lock = new object();

        private static BusinessUtils _instance = null;

        public static BusinessUtils Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        _instance = new BusinessUtils();
                    }
                }

                return _instance;
            }
        }

        #region 做法操作集合
        private List<ProductMakeType> _makeTypeList = null;
        /// <summary>
        /// 做法分类集合
        /// </summary>
        public List<ProductMakeType> GetMakeTypeList
        {
            get
            {
                if (_makeTypeList == null)
                {
                    //做法分类数据源
                    using (var db = Global.Instance.OpenDataBase)
                    {
                        this._makeTypeList = db.Query<ProductMakeType>().OrderBy(x => x.SeqNo).ToList();
                    }

                    if (this._makeTypeList == null)
                    {
                        this._makeTypeList = new List<ProductMakeType>();
                    }
                }
                return this._makeTypeList;
            }
        }

        /// <summary>
        /// 根据做法类型ID获取做法类型对象
        /// </summary>
        /// <param name="typeId"></param>
        public ProductMakeType GetMakeTypeById(string typeId)
        {
            return GetMakeTypeList.Find(x => x.Id == typeId);
        }

        private List<ProductMakeDetail> _makeDetailList = null;
        /// <summary>
        /// 获取公共做法
        /// </summary>
        /// <returns></returns>
        public List<ProductMakeDetail> GetCommonMakes()
        {
            try
            {
                if (_makeDetailList == null)
                {

                    using (var db = Global.Instance.OpenDataBase)
                    {
                        _makeDetailList = db.Query<ProductMakeDetail>().ToList();
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取公有做法异常");
            }

            if (_makeDetailList == null)
            {
                _makeDetailList = new List<ProductMakeDetail>();
            }
            return _makeDetailList;
        }

        /// <summary>
        /// 根据商品ID获取商品所有做法（包含私有做法）
        /// </summary>
        /// <param name="productId"></param>
        /// <returns></returns>
        public List<ProductMakeDetail> GetMakesByProductId(string productId)
        {
            var commonMakes = GetCommonMakes();
            List<ProductMakeDetail> makeDetailList = new List<ProductMakeDetail>();
            makeDetailList.AddRange(commonMakes);
            try
            {
                //做法数据源
                List<ProductMakeDetailPrivate> makeDetailPrivateList = null;
                using (var db = Global.Instance.OpenDataBase)
                {
                    makeDetailPrivateList = db.Query<ProductMakeDetailPrivate>("where productId = @0", productId).ToList();
                }

                foreach (var pri in makeDetailPrivateList)
                {
                    var isExist = makeDetailList.Exists(x => x.Id == pri.MakeId);
                    //不存在，做法列表增加私有做法
                    if (!isExist)
                    {
                        ProductMakeDetail detail = new ProductMakeDetail();
                        detail.Id = pri.MakeId;
                        detail.Memo = pri.Memo;
                        detail.No = pri.No;
                        detail.Spell = pri.Spell;
                        detail.TypeId = pri.TypeId;
                        detail.AddPrice = pri.AddPrice;
                        detail.QtyFlag = pri.QtyFlag;
                        detail.OrderNo = pri.OrderNo;
                        detail.Color = pri.Color;
                        detail.Ext1 = pri.Ext1;
                        detail.Ext2 = pri.Ext2;
                        detail.Ext3 = pri.Ext3;

                        makeDetailList.Add(detail);
                    }
                }
                makeDetailList = makeDetailList.OrderBy(x => x.OrderNo).ToList();
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取商品所有做法异常");
            }

            if (makeDetailList == null)
            {
                makeDetailList = new List<ProductMakeDetail>();
            }
            return makeDetailList;
        }

        #endregion

        /// <summary>
        /// 初始化收银员权限
        /// </summary>
        public void InitPermission()
        {
            List<WorkerRole> roles = null;

            StoreInfo store = null;

            using (var db = Global.Instance.OpenDataBase)
            {
                string sql = string.Format("select [id],[tenantId],[storeId],[workerId],[roleId],[discount],[free],[ext1],[ext2],[ext3],[createUser],[createDate],[modifyUser],[modifyDate]  from [pos_worker_role] where [workerId] ='{0}';", Global.Instance.Worker.Id);

                roles = db.Fetch<WorkerRole>(sql);

                //门店信息不能用员工表中storeId
                store = db.FirstOrDefault<StoreInfo>("where id = @0", Global.Instance.Authc.StoreId);
            }

            //收银员归属门店信息
            Global.Instance.Worker.StoreInfo = store;

            if (roles != null && roles.Count > 0)
            {
                Global.Instance.Worker.MaxDiscountRate = roles.Min(x => x.Discount);
                Global.Instance.Worker.MaxFreeAmount = roles.Max(x => x.Free);
            }
            else
            {
                //参数设置有问题，系统默认不打折
                Global.Instance.Worker.MaxDiscountRate = 100;

                Global.Instance.Worker.MaxFreeAmount = 0;
            }

            logger.Info("收银员{0},最大折扣{1},最大免单{2}", Global.Instance.Worker.No, Global.Instance.Worker.MaxDiscountRate, Global.Instance.Worker.MaxFreeAmount);

            var permission = new List<string>();

            //lock (Global.Instance.SyncLock)
            //{
            using (var db = Global.Instance.OpenDataBase)
            {
                string sql = string.Format("select [id] ,[tenantId] ,[storeId] ,[moduleNo] ,[createUser] ,[createDate] ,[modifyUser] ,[modifyDate] from [pos_worker_permissions] where workerId = '{0}';", Global.Instance.Worker.Id);
                var lists = db.Fetch<WorkerPermissions>(sql);
                if (lists != null && lists.Count > 0)
                {
                    permission = lists.ConvertAll(x => x.ModuleNo);
                }
            }

            //}

            Global.Instance.Worker.Permission = permission;

            logger.Info("收银员{0},权限{1}", Global.Instance.Worker.No, JsonUtils.Serialize(Global.Instance.Worker.Permission));

            //加载门店营业方案
            BusinessPlan businessPlan = null;
            using (var db = Global.Instance.OpenDataBase)
            {
                businessPlan = db.FirstOrDefault<BusinessPlan>("where 1=1");
            }
            if (businessPlan == null)
            {
                businessPlan = new BusinessPlan();
                businessPlan.StartType = 0;
                businessPlan.StartTime = "00:00";
                businessPlan.EndType = 1;
                businessPlan.EndTime = "00:00";
            }
            Global.Instance.BusinessPlan = businessPlan;
            logger.Info("门店营业方案：<{0}>{1}-<{2}>{3}", businessPlan.StartType, businessPlan.StartTime, businessPlan.EndType, businessPlan.EndTime);

        }

        /// <summary>
        /// 获取指定收银员权限
        /// </summary>
        /// <param name="worker">收银员</param>
        /// <returns>MaxDiscountRate、MaxFreeAmount、List<string>、Worker</returns>
        public Tuple<decimal, decimal, List<string>, Worker> GetPermission(Worker worker)
        {
            //最大折扣
            decimal maxDiscountRate = 100;
            //最高免单
            decimal maxFreeAmount = 0;
            //权限模块
            var permission = new List<string>();

            if (worker == null)
            {
                decimal _maxDiscountRate = (maxDiscountRate / Convert.ToDecimal(100.0));
                decimal.TryParse(_maxDiscountRate.ToString("0.##"), out _maxDiscountRate);

                new Tuple<decimal, decimal, List<string>, Worker>(_maxDiscountRate, maxFreeAmount, permission, worker);
            }

            List<WorkerRole> roles = new List<WorkerRole>();
            using (var db = Global.Instance.OpenDataBase)
            {
                string sql = string.Format("select [id],[tenantId],[storeId],[workerId],[roleId],[discount],[free],[ext1],[ext2],[ext3],[createUser],[createDate],[modifyUser],[modifyDate]  from [pos_worker_role] where [workerId] ='{0}';", worker.Id);
                roles = db.Fetch<WorkerRole>(sql);

                sql = string.Format("select [id] ,[tenantId] ,[storeId] ,[moduleNo] ,[createUser] ,[createDate] ,[modifyUser] ,[modifyDate] from [pos_worker_permissions] where workerId = '{0}';", worker.Id);
                var lists = db.Fetch<WorkerPermissions>(sql);
                if (lists != null && lists.Count > 0)
                {
                    permission = lists.ConvertAll(x => x.ModuleNo);
                }
            }

            if (roles != null && roles.Count > 0)
            {
                maxDiscountRate = roles.Min(x => x.Discount);
                maxFreeAmount = roles.Max(x => x.Free);
            }
            else
            {
                //参数设置有问题，系统默认不打折
                maxDiscountRate = 100;
                maxFreeAmount = 0;
            }


            decimal v = (maxDiscountRate / Convert.ToDecimal(100.0));
            decimal.TryParse(v.ToString("0.##"), out v);

            logger.Info("收银员<{0}>,最大折扣<{1}>,最大免单<{2}>,权限<{3}>", worker.No, v, maxFreeAmount, JsonUtils.Serialize(permission));

            return new Tuple<decimal, decimal, List<string>, Worker>(v, maxFreeAmount, permission, worker);
        }


        /// <summary>
        /// 新开班次
        /// </summary>
        public void WorkerLogin()
        {
            try
            {
                lock (Global.Instance.SyncLock)
                {
                    using (var db = Global.Instance.OpenDataBase)
                    {
                        StringBuilder sqlBuld = new StringBuilder();
                        sqlBuld.Append(" select id,tenantId,status,storeId,storeNo,workerId,workerNo,planId,name,starTime, ");
                        sqlBuld.Append(" endTime,posNo,loginTime,shiftTime,isLogin,no,workerName,imprest from pos_business_plan_log ");
                        sqlBuld.Append(" where status = 0 and storeId = '{0}' and workerId ='{1}' and posNo = '{2}'; ");


                        string sql = string.Format(sqlBuld.ToString(), Global.Instance.Authc.StoreId, Global.Instance.Worker.Id, Global.Instance.Authc.PosNo);

                        var businessPlanLog = db.FirstOrDefault<BusinessPlanLog>(sql);

                        if (businessPlanLog != null)
                        {
                            Global.Instance.BusinessPlanLog = businessPlanLog;
                        }
                        else
                        {
                            string shiftNo = OrderUtils.Instance.GenerateBatchNo();

                            businessPlanLog = new BusinessPlanLog();
                            businessPlanLog.Id = IdWorkerUtils.Instance.NextId();
                            businessPlanLog.TenantId = Global.Instance.Authc.TenantId;
                            businessPlanLog.Status = 0;
                            businessPlanLog.StoreId = Global.Instance.Authc.StoreId;
                            businessPlanLog.StoreNo = Global.Instance.Authc.StoreNo;
                            businessPlanLog.WorkerId = Global.Instance.Worker.Id;
                            businessPlanLog.WorkerNo = Global.Instance.Worker.No;
                            businessPlanLog.PlanId = "";
                            businessPlanLog.Name = "默认班次";
                            businessPlanLog.StarTime = "";
                            businessPlanLog.EndTime = "";
                            businessPlanLog.PosNo = Global.Instance.Authc.PosNo;
                            businessPlanLog.LoginTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            businessPlanLog.ShiftTime = null;
                            businessPlanLog.IsLogin = 1;
                            businessPlanLog.No = shiftNo;
                            businessPlanLog.WorkerName = Global.Instance.Worker.Name;
                            businessPlanLog.Imprest = 0.00M;
                            // 没有数据的话新建数据
                            db.Save(businessPlanLog);

                            Global.Instance.BusinessPlanLog = businessPlanLog;
                        }

                    }

                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "处理登录班次异常");
            }
        }

        /// <summary>
        /// 建立新的订单项
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="product"></param>
        /// <returns></returns>
        public OrderItem NewOrderItem(OrderObject orderObject, ProductExt product, OrderRowState rowState = OrderRowState.None)
        {
            var row = new OrderItem();

            //系统主键
            row.Id = IdWorkerUtils.Instance.NextId();

            //租户编码
            row.TenantId = Global.Instance.Authc.TenantId;
            //订单ID
            row.OrderId = orderObject.Id;
            //订单编号
            row.TradeNo = orderObject.TradeNo;
            //行序号，随着行的增加或删除改变
            row.OrderNo = orderObject.OrderCount + 1;

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

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

            //默认情况下，折后单价和零售价一样
            row.DiscountPrice = row.Price;

            //商品ID
            row.ProductId = product.Id;
            //商品编号
            row.ProductNo = product.No;
            //单品名称
            row.Name = product.Name;
            //单品简称
            row.ShortName = product.ShortName;

            //规格ID
            row.SpecId = product.SpecId;
            //规格名称
            row.SpecName = product.SpecName;

            //品类ID
            row.TypeId = product.TypeId;
            //品类名称
            row.TypeName = product.TypeName;

            //商品单位ID
            row.ProductUnitId = product.UnitId;
            //商品单位名称
            row.ProductUnitName = product.UnitName;

            //厨打标识
            row.Chuda = product.Chuda;
            row.ChudaFlag = product.ChudaFlag;
            row.ChudaQty = 0;

            //出品标识
            row.Chupin = product.Chupin;
            row.ChupinFlag = product.ChupinFlag;
            row.ChupinQty = 0;

            //厨打标签标识
            row.ChuDaLabel = product.ChuDaLabel;
            row.ChuDaLabelFlag = product.ChuDaLabelFlag;
            row.ChuDaLabelQty = 0;

            var KDSLists = Global.KdsPlan._kdsPlanList;
            if (product.KdsFlag == 1 && (product.Chuxian == null || "".Equals(product.Chuxian)) && KDSLists.Count > 0)
            {
                KdsPlan kdsPlan = KDSLists[0];
                //厨显标识
                row.Chuxian = kdsPlan.Id;
                row.ChuxianFlag = "1";
                row.ChuxianQty = 0;
                row.ChuxianTime = 5;
            }
            else
            {
                //厨显标识
                row.Chuxian = product.Chuxian;
                row.ChuxianFlag = product.ChuxianFlag;
                row.ChuxianQty = 0;
                row.ChuxianTime = product.ChuxianTime;
            }
            if (product.KdsFlag == 1 && (product.Chuxian == null || "".Equals(product.Chuxian)) && KDSLists.Count > 0)
            {
                KdsPlan kdsPlan = KDSLists[0];
                //厨显标识
                row.KdsChupin = kdsPlan.Id;
                row.KdsChupinFlag = "1";
                row.KdsChupinQty = 0;
                row.KdsChupinTime = 5;
            }
            else
            {
                //KDS出品标识
                row.KdsChupin = product.KdsChupin;
                row.KdsChupinFlag = product.KdsChupinFlag;
                row.KdsChupinQty = 0;
                row.KdsChupinTime = product.KdsChupinTime;
            }


            //是否可折扣
            row.DiscountFlag = product.DiscountFlag;
            //是否可议价
            row.CurrentFlag = product.CurrentFlag;
            //是否主食
            row.TapleFlag = product.TapleFlag;
            //是否称重
            row.WeighFlag = product.WeighFlag;
            //打印标签
            row.LabelPrintFlag = product.LabelPrintFlag;
            row.LabelQty = 0;
            //会员折上折
            row.MebDiscountFlag = product.MebDiscountFlag;
            //允许赠送
            row.GiveFlag = product.GiveFlag;
            //是否管理库存
            row.StockFlag = product.StockFlag;
            //允许促销
            row.PromotionFlag = product.PromotionFlag;

            if (rowState == OrderRowState.None)
            {
                //是否为套餐
                if (product.SuitFlag == 1)
                {
                    row.RowState = OrderRowState.套餐主;
                }
                else
                {
                    row.RowState = OrderRowState.普通;
                }
            }
            else
            {
                row.RowState = rowState;
            }


            //单品优惠列表
            row.Promotions = new List<PromotionItem>();
            //单品做法口味
            row.Flavors = new List<FlavorItem>();
            //对应的商品信息
            row.ProductExt = product;

            return row;

        }

        /// <summary>
        /// 离线支付，顾客扫静态付款码
        /// </summary>
        public Tuple<bool, string> OfflinePay(OrderObject orderObject, decimal inputMoney)
        {
            logger.Info("操作离线支付");

            //计算抹零金额
            decimal malingAmount = OrderUtils.MalingAmount(orderObject.ReceivableAmount, null);
            //将抹零金额记入主单对象
            orderObject.MalingAmount = malingAmount;

            //计算实际应收的金额，扣除抹零
            orderObject.PaidAmount = orderObject.ReceivableAmount - orderObject.MalingAmount;

            var offlinePayMode = OrderUtils.GetOfflinePayMode();

            if (offlinePayMode == null)
            {
                return new Tuple<bool, string>(false, "门店未绑定离线支付收银方式");
            }

            //构建离线支付方式
            PayItem item = OrderUtils.ToPayItem(offlinePayMode);

            //订单ID
            item.OrderId = orderObject.Id;
            //收银票号
            item.TradeNo = orderObject.TradeNo;

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

            //操作员输入的金额
            item.PaidAmount = inputMoney;

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

            item.CardNo = "";
            item.Memo = "离线支付";

            item.Status = (int)OrderPaymentStatus.已付款;
            item.StatusDesc = "离线支付结账";

            item.PayTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            //将支付方式压入整单支付明细中
            orderObject.Pays.Add(item);

            //确认订单数据是否满足结账逻辑：消费金额 = 实收金额 + 优惠金额 + 抹零金额
            if (orderObject.Amount == orderObject.PaidAmount + orderObject.DiscountAmount + orderObject.MalingAmount)
            {
                //抹零记入支付方式
                var malingResult = this.BuilderMalingPayMode(orderObject);
                if (!malingResult.Item1)
                {
                    return new Tuple<bool, string>(false, malingResult.Item2);
                }

                //客显
                GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Change, orderObject.ChangeAmount.ToString("f2"));

                //支付方式分摊
                this.BuilderItemPayShared(orderObject);

                //整单状态
                orderObject.OrderStatus = OrderStatus.已完成;
                //整单支付状态
                orderObject.PaymentStatus = OrderPaymentStatus.已付款;

                var isException = OrderUtils.Instance.SaveOrderObject(orderObject);

                if (!isException)
                {
                    logger.Info("开始打印");

                    orderObject.PrintType = 0;
                    orderObject.RPrint = false;
                    //开始打印
                    PrintHelper.PrintOrderObject(orderObject);

                    logger.Info("本单交易完成");
                    return new Tuple<bool, string>(true, "本单交易完成");
                }
                else
                {
                    return new Tuple<bool, string>(false, "订单保存异常，请联系管理人员！");
                }
            }
            else
            {

                //清理掉上面压入到支付方式明细中的item,避免收银员多次点击快速收银造成数据重复
                orderObject.Pays.Remove(item);
                return new Tuple<bool, string>(false, "结账条件不满足");
            }

        }

        /// <summary>
        /// 现金结账
        /// </summary>
        public Tuple<bool, string> QuickPay(OrderObject orderObject, decimal inputMoney)
        {
            logger.Info("操作现金结账");

            //计算抹零金额
            decimal malingAmount = OrderUtils.MalingAmount(orderObject.ReceivableAmount, null);
            //将抹零金额记入主单对象
            orderObject.MalingAmount = malingAmount;

            //计算实际应收的金额，扣除抹零
            orderObject.PaidAmount = orderObject.ReceivableAmount - orderObject.MalingAmount;

            //实收金额,已经扣除抹零
            decimal paidAmount = orderObject.PaidAmount;

            //找零金额
            decimal changeAmount = inputMoney <= paidAmount ? 0 : (inputMoney - paidAmount);

            //前台收银找零不允许超过100元
            bool notAllowMoreOneHundred = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_MORE_ONE_HUNDRED);
            if (notAllowMoreOneHundred && changeAmount > 100)
            {
                return new Tuple<bool, string>(false, "找零不允许超过100元");
            }

            //输入是否满足条件:实收金额 = 输入金额 - 找零金额
            bool isVerify = (paidAmount == (inputMoney - changeAmount));
            if (isVerify)
            {
                logger.Info("满足条件现金结账条件");

                var cashPayMode = OrderUtils.GetDefaultPayMode();

                //构建现金支付方式
                PayItem item = OrderUtils.ToPayItem(cashPayMode);

                //订单ID
                item.OrderId = orderObject.Id;
                //收银票号
                item.TradeNo = orderObject.TradeNo;

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

                //操作员输入的金额
                item.PaidAmount = inputMoney;

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

                item.CardNo = "";
                item.Memo = "快速结账";

                item.Status = (int)OrderPaymentStatus.已付款;
                item.StatusDesc = "现金快速结账";

                item.PayTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                //将支付方式压入整单支付明细中
                orderObject.Pays.Add(item);

                //确认订单数据是否满足结账逻辑：消费金额 = 实收金额 + 优惠金额 + 抹零金额
                if (orderObject.Amount == orderObject.PaidAmount + orderObject.DiscountAmount + orderObject.MalingAmount)
                {
                    //抹零记入支付方式
                    var malingResult = this.BuilderMalingPayMode(orderObject);
                    if (!malingResult.Item1)
                    {
                        return new Tuple<bool, string>(false, malingResult.Item2);
                    }

                    //会员积分充值
                    if (orderObject.IsMember == 1)
                    {
                        var result = BusinessUtils.Instance.AddCardPoint4Order(orderObject);
                        if (!result.Item1)
                        {
                            return new Tuple<bool, string>(false, result.Item2);
                        }
                    }

                    //核销实体券
                    var storeCouponResult = ConsumeStoreCoupon(orderObject);
                    if (!storeCouponResult.Item1)
                    {
                        return new Tuple<bool, string>(false, storeCouponResult.Item2);
                    }
                    //核销卡券
                    var couponResult = ConsumeElecCoupon(orderObject);
                    if (!couponResult.Item1)
                    {
                        return new Tuple<bool, string>(false, couponResult.Item2);
                    }
                    //美团券核销
                    var meituanCouponResult = MeituanCouponConsume(orderObject);
                    if (!meituanCouponResult.Item1)
                    {
                        return new Tuple<bool, string>(false, "美团券核销:" + meituanCouponResult.Item2);
                    }
                    //客显
                    GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Change, orderObject.ChangeAmount.ToString("f2"));

                    //支付方式分摊
                    this.BuilderItemPayShared(orderObject);

                    //整单状态
                    orderObject.OrderStatus = OrderStatus.已完成;
                    //整单支付状态
                    orderObject.PaymentStatus = OrderPaymentStatus.已付款;

                    var isException = OrderUtils.Instance.SaveOrderObject(orderObject);

                    if (!isException)
                    {
                        logger.Info("开始打印");

                        orderObject.PrintType = 0;
                        orderObject.RPrint = false;
                        //开始打印
                        PrintHelper.PrintOrderObject(orderObject);

                        logger.Info("本单交易完成");
                        return new Tuple<bool, string>(true, "本单交易完成");
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, "订单保存异常，请联系管理人员！");
                    }
                }
                else
                {

                    //清理掉上面压入到支付方式明细中的item,避免收银员多次点击快速收银造成数据重复
                    orderObject.Pays.Remove(item);
                    return new Tuple<bool, string>(false, "结账条件不满足");
                }
            }
            else
            {
                return new Tuple<bool, string>(false, "不满足结账条件");
            }
        }



        /// <summary>
        /// 美团券结账
        /// </summary>
        public Tuple<bool, string> MeituanCouponPay(string couponCode, OrderObject orderObject)
        {
            logger.Info("操作美团券结账");

            //将抹零金额记入主单对象
            orderObject.MalingAmount = 0;
            //计算实际应收的金额，扣除抹零
            orderObject.PaidAmount = orderObject.ReceivableAmount - orderObject.MalingAmount;

            //实收金额
            decimal paidAmount = orderObject.PaidAmount;

            logger.Info("满足条件现金结账条件");

            var meituanPayMode = OrderUtils.GetMeituanPayMode();

            //构建现金支付方式
            PayItem item = OrderUtils.ToPayItem(meituanPayMode);

            //订单ID
            item.OrderId = orderObject.Id;
            //收银票号
            item.TradeNo = orderObject.TradeNo;

            //操作员输入的金额
            item.PaidAmount = paidAmount;

            //实收金额
            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);

            //确认订单数据是否满足结账逻辑：消费金额 = 实收金额 + 优惠金额 + 抹零金额
            if (orderObject.Amount == orderObject.PaidAmount + orderObject.DiscountAmount + orderObject.MalingAmount)
            {
                //抹零记入支付方式
                var malingResult = this.BuilderMalingPayMode(orderObject);
                if (!malingResult.Item1)
                {
                    return new Tuple<bool, string>(false, malingResult.Item2);
                }

                //美团券核销
                var meituanCouponResult = MeituanCouponConsume(orderObject);
                if (!meituanCouponResult.Item1)
                {
                    return new Tuple<bool, string>(false, "美团券核销:" + meituanCouponResult.Item2);
                }
                //客显
                GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Change, orderObject.ChangeAmount.ToString("f2"));

                //支付方式分摊
                this.BuilderItemPayShared(orderObject);

                //整单状态
                orderObject.OrderStatus = OrderStatus.已完成;
                //整单支付状态
                orderObject.PaymentStatus = OrderPaymentStatus.已付款;

                var isException = OrderUtils.Instance.SaveOrderObject(orderObject);

                if (!isException)
                {
                    logger.Info("开始打印");

                    orderObject.PrintType = 0;
                    orderObject.RPrint = false;
                    //开始打印
                    PrintHelper.PrintOrderObject(orderObject);

                    logger.Info("本单交易完成");
                    return new Tuple<bool, string>(true, "本单交易完成");
                }
                else
                {
                    return new Tuple<bool, string>(false, "订单保存异常，请联系管理人员！");
                }
            }
            else
            {

                //清理掉上面压入到支付方式明细中的item,避免收银员多次点击快速收银造成数据重复
                orderObject.Pays.Remove(item);
                return new Tuple<bool, string>(false, "结账条件不满足");
            }

        }


        /// <summary>
        /// 电话外卖结账
        /// </summary>
        public Tuple<bool, string> DeliveryPay(OrderObject orderObject)
        {
            logger.Info("操作电话外卖挂账");
            //计算抹零金额
            decimal malingAmount = OrderUtils.MalingAmount(orderObject.ReceivableAmount, null);
            //将抹零金额记入主单对象
            orderObject.MalingAmount = malingAmount;
            //计算实际应收的金额，扣除抹零
            orderObject.PaidAmount = orderObject.ReceivableAmount - orderObject.MalingAmount;


            var deliveryPayMode = OrderUtils.GetDeliveryPayMode();

            if (deliveryPayMode == null)
            {
                return new Tuple<bool, string>(false, "门店未绑定电话外卖收银方式，请联系管理员绑定");
            }

            //构建电话外卖支付方式
            PayItem item = OrderUtils.ToPayItem(deliveryPayMode);

            //订单ID
            item.OrderId = orderObject.Id;
            //收银票号
            item.TradeNo = orderObject.TradeNo;

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

            //操作员输入的金额
            item.PaidAmount = orderObject.PaidAmount;

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

            item.CardNo = "";
            item.Memo = "电话外卖挂账";

            item.Status = (int)OrderPaymentStatus.未付款;
            item.StatusDesc = "电话外卖挂账";

            item.PayTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            //将支付方式压入整单支付明细中
            orderObject.Pays.Add(item);

            //确认订单数据是否满足结账逻辑：消费金额 = 实收金额 + 优惠金额 + 抹零金额
            if (orderObject.Amount == orderObject.PaidAmount + orderObject.DiscountAmount + orderObject.MalingAmount)
            {
                //抹零记入支付方式
                BusinessUtils.Instance.BuilderMalingPayMode(orderObject);

                //客显
                GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Change, orderObject.ChangeAmount.ToString("f2"));

                //电话外卖单
                orderObject.OrderType = OrderType.电话外卖;
                //整单状态
                orderObject.OrderStatus = OrderStatus.等待付款;
                //整单支付状态
                orderObject.PaymentStatus = OrderPaymentStatus.未付款;

                var isException = OrderUtils.Instance.SaveOrderObject(orderObject);

                if (!isException)
                {
                    logger.Info("开始打印");

                    orderObject.PrintType = 0;

                    orderObject.RPrint = false;
                    //开始打印
                    PrintHelper.PrintOrderObject(orderObject);

                    logger.Info("本单交易完成");
                    return new Tuple<bool, string>(true, "本单交易完成");
                }
                else
                {
                    return new Tuple<bool, string>(false, "订单保存异常，请联系管理人员！");
                }
            }
            else
            {
                //清理掉上面压入到支付方式明细中的item,避免收银员多次点击快速收银造成数据重复
                orderObject.Pays.Remove(item);
                return new Tuple<bool, string>(false, "结账条件不满足");
            }

        }

        /// <summary>
        /// 耗料库存  （带lock） 
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> OrderBurden(OrderObject orderObject)
        {
            lock (_lock)
            {
                try
                {
                    using (var db = Global.Instance.OpenDataBase)
                    {
                        //8、保存耗料信息
                        List<OrderProductBurden> orderBurdenList = new List<OrderProductBurden>();

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

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

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

                            }
                            db.InsertBatch<OrderProductBurden>(list);

                        }
                    }
                    return new Tuple<bool, string>(true, "");
                }
                catch (Exception ex)
                {
                    logger.Info("添加耗料数据异常，单号ID：" + orderObject.Id + "\t 异常信息：" + ex.Message);
                    return new Tuple<bool, string>(false, ex.Message);
                }

            }
        }

        /// <summary>
        /// 收银台完成结账通知处理
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> OrderFinished(OrderObject orderObject)
        {
            //核销实体券
            var storeCouponResult = ConsumeStoreCoupon(orderObject);
            if (!storeCouponResult.Item1)
            {
                return new Tuple<bool, string>(false, storeCouponResult.Item2);
            }
            //核销卡券
            var couponResult = ConsumeElecCoupon(orderObject);
            if (!couponResult.Item1)
            {
                return new Tuple<bool, string>(false, couponResult.Item2);
            }

            //客显
            GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Change, orderObject.ChangeAmount.ToString("f2"));

            //抹零附加记入支付方式
            this.BuilderMalingPayMode(orderObject);

            //支付方式分摊
            this.BuilderItemPayShared(orderObject);

            //整单状态
            orderObject.OrderStatus = OrderStatus.已完成;
            //整单支付状态
            orderObject.PaymentStatus = OrderPaymentStatus.已付款;

            var isException = OrderUtils.Instance.SaveOrderObject(orderObject);

            if (!isException)
            {
                logger.Info("开始打印");
                orderObject.PrintType = 0;
                orderObject.RPrint = false;
                //开始打印
                PrintHelper.PrintOrderObject(orderObject);

                logger.Info("本单交易完成");
                return new Tuple<bool, string>(true, "本单交易完成");
            }
            else
            {
                return new Tuple<bool, string>(false, "订单保存异常，请联系管理人员！");
            }
        }

        /// <summary>
        /// 创建抹零支付方式
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> BuilderMalingPayMode(OrderObject orderObject)
        {
            //将抹零记入支付方式列表
            if (orderObject.MalingAmount != 0)
            {
                var malingPayMode = OrderUtils.GetMalingPayMode();

                if (malingPayMode == null)
                {
                    return new Tuple<bool, string>(false, "云端未配置抹零支付方式");
                }
                //构建抹零支付方式
                PayItem maling = OrderUtils.ToPayItem(malingPayMode);

                maling.OrderId = orderObject.Id;
                maling.TradeNo = orderObject.TradeNo;

                //抹零金额
                maling.Amount = orderObject.MalingAmount;
                //实收金额
                maling.PaidAmount = orderObject.MalingAmount;
                //找零金额
                maling.ChangeAmount = 0;

                maling.CardNo = "";
                maling.Memo = "抹零";

                maling.Status = (int)OrderPaymentStatus.已付款;
                maling.StatusDesc = "抹零";

                maling.PayTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                //将支付方式压入整单支付明细中
                orderObject.Pays.Add(maling);
            }
            return new Tuple<bool, string>(true, "处理成功");
        }

        /// <summary>
        /// 构建订单明细支付方式分摊
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> BuilderItemPayShared(OrderObject orderObject)
        {
            var result = new Tuple<bool, string>(false, "初始错误");
            try
            {
                //找到未分摊的支付方式
                var waitSharedPay = orderObject.Pays.FindAll(x => !orderObject.Items.Exists(y => y.ItemPayList != null && y.ItemPayList.Exists(z => z.PayId == x.Id)));
                if (waitSharedPay != null && waitSharedPay.Count > 0)
                {
                    foreach (var pay in waitSharedPay)
                    {
                        //本次分摊总额
                        #region 20231213 subin 修改待分摊金额由原先的实收金额改为实收-找零金额
                        //var waitSharedAmount = pay.PaidAmount;
                        var waitSharedAmount = pay.PaidAmount - pay.ChangeAmount; 
                        #endregion
                        //已分摊金额
                        var alreadyShared = decimal.Zero;

                        //商品可参与分摊剩余总额（应收-已分摊）
                        var fineItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.TotalReceivableAmount != decimal.Zero);
                        var allItemFineAmount = fineItems.Sum(x => x.TotalReceivableAmount - (x.ItemPayList != null ? x.ItemPayList.Sum(y => y.ShareAmount) : decimal.Zero));
                        int i = 0;
                        foreach (var item in fineItems)
                        {
                            i++;
                            decimal share = decimal.Zero;
                            //本商品剩余可分摊的余额
                            var itemFineAmount = item.TotalReceivableAmount - (item.ItemPayList != null ? item.ItemPayList.Sum(x => x.ShareAmount) : decimal.Zero);
                            if (i >= fineItems.Count)
                            {
                                //最后一个用减法
                                share = waitSharedAmount - alreadyShared;
                            }
                            else
                            {
                                //排除整单全赠送的情况
                                if (allItemFineAmount != 0M)
                                {
                                    var rate = itemFineAmount / allItemFineAmount;
                                    share = DecimalUtils.ToRound(waitSharedAmount * rate, 2);
                                }
                                else
                                {
                                    share = 0M;
                                }
                            }

                            if (share == 0M)
                            {
                                //此商品不分摊，可能是已经分摊的和应收一样了，也就是分摊够了
                                continue;
                            }

                            //计算支付方式分摊
                            OrderItemPay itemPay = new OrderItemPay()
                            {
                                Id = IdWorkerUtils.Instance.NextId(),
                                TenantId = pay.TenantId,
                                OrderId = pay.OrderId,
                                TradeNo = pay.TradeNo,
                                PayId = pay.Id,
                                ItemId = item.Id,
                                No = pay.No,
                                Name = pay.Name,
                                ProductId = item.ProductId,
                                SpecId = item.SpecId,
                                ShareAmount = share,
                                ShareCouponLeastCost = decimal.Zero,
                                RefundAmount = decimal.Zero
                            };
                            if (item.ItemPayList == null)
                            {
                                item.ItemPayList = new List<OrderItemPay>();
                            }
                            item.ItemPayList.Add(itemPay);
                            alreadyShared += share;
                        }
                    }
                }

                result = new Tuple<bool, string>(true, "分摊完成");
            }
            catch (Exception ex)
            {
                result = new Tuple<bool, string>(false, "支付方式分摊发生异常");
                logger.Error(ex, "支付方式分摊异常");
                Task.Factory.StartNew(() =>
                {
                    Global.Instance.BugReport(ex, "支付方式分摊异常");
                });
            }
            return result;
        }

        /// <summary>
        /// 创建新订单对象
        /// </summary>
        /// <returns></returns>
        public OrderObject NewOrderObject()
        {

            var orderObject = new OrderObject();

            //订单ID
            orderObject.Id = IdWorkerUtils.Instance.NextId();
            //订单内部ID
            orderObject.ObjectId = ObjectId.GenerateNewStringId();

            //门店ID
            orderObject.StoreId = Global.Instance.Authc.StoreId;
            //门店编码
            orderObject.StoreNo = Global.Instance.Authc.StoreNo;
            //门店名称
            orderObject.StoreName = Global.Instance.Worker.StoreInfo?.Name;
            //操作员工号
            orderObject.WorkerNo = Global.Instance.Worker.No;
            //操作员名称
            orderObject.WorkerName = Global.Instance.Worker.Name;
            //POS编号
            orderObject.PosNo = Global.Instance.Authc.PosNo;
            //租户ID
            orderObject.TenantId = Global.Instance.Authc.TenantId;

            //订单销售时间
            orderObject.SaleDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            //支付明细
            orderObject.Pays = new List<PayItem>();

            //整单享受的优惠列表
            orderObject.Promotions = new List<PromotionOrder>();

            //MAC地址
            string macAddress = (DeviceUtils.Instance.MacAddress != null ? DeviceUtils.Instance.MacAddress : "").Trim();

            logger.Info("mac地址:" + macAddress);

            orderObject.MacAddress = string.IsNullOrEmpty(macAddress) ? "" : (macAddress.Length > 32 ? macAddress.Substring(0, 25) : macAddress);
            //本地IP地址
            orderObject.IpAddress = DeviceUtils.Instance.IPAddress;
            //设备名称
            orderObject.DeviceName = DeviceUtils.Instance.ComputerName;

            //班次名称
            orderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;
            //班次编号
            orderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;

            //订单标识为 新建状态
            orderObject.OrderStatus = OrderStatus.新建单;
            //订单创建时间
            orderObject.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            //订单创建人
            orderObject.CreateUser = Global.Instance.Worker.Name;

            string[] day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
            string weeker = day[Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"))].ToString();

            //星期
            orderObject.Weeker = weeker;
            //天气
            orderObject.Weather = string.Empty;

            //重置刷卡状态
            orderObject.Member = null;

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

            return orderObject;
        }

        /// <summary>
        /// 构建购物车行
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="product"></param>
        /// <param name="master"></param>
        /// <returns></returns>
        public List<OrderItem> BuildGridRow(OrderObject orderObject, ProductExt product, OrderItem master)
        {
            List<OrderItem> rows = new List<OrderItem>();

            //道菜ID
            master.SuitId = "";
            //道菜基准加价
            master.SuitAddPrice = 0;
            //道菜基准数量
            master.SuitQuantity = 0;
            //道菜基准加价后金额
            master.SuitAmount = 0;

            //主菜默认数量
            if (master.Quantity == 0)
            {
                master.Quantity = 1;
            }

            //主菜优惠 mod by yangaming 180205 赠送商品
            master.Discount = master.DiscountAmount;

            //界面行上是否输出下划线
            master.Underline = 1;
            //如果是套餐，不输出下划线
            if (product.SuitFlag == 1)
            {
                master.Underline = 0;
            }

            //是否包含做法
            master.Flavor = 0;

            //当前行的父ID mod by yangaming 180205 赠送商品
            //master.ParentId = "";
            //当前行组标识
            if (string.IsNullOrEmpty(master.Group))
            {
                master.Group = master.Id;
            }
            //加料
            master.Scheme = "";

            //使用会员优惠
            //AddMemberPromotion(orderObject, master);

            //将当前行记入
            rows.Add(master);

            //套菜
            if (product.SuitFlag == 1)
            {
                var details = new List<SuitExt>();

                lock (Global.Instance.SyncLock)
                {
                    using (var db = Global.Instance.OpenDataBase)
                    {
                        details = db.Fetch<SuitExt>(string.Format(SqlConstant.SuitExt, product.Id));
                    }
                }

                var lists = details.FindAll(x => x.DefaultFlag == 1).ToList();

                int inx = 0;
                foreach (SuitExt suit in lists)
                {
                    //将当前SuitExt序列化
                    var _json = JsonUtils.Serialize(suit);
                    //反序列化为ProductExt对象
                    var _product = JsonUtils.Deserialize<ProductExt>(_json);


                    //新建套菜明细
                    var row = NewOrderItem(orderObject, _product);

                    //标识为套餐明细
                    row.RowState = OrderRowState.套餐明;

                    //道菜ID
                    row.SuitId = suit.SuitId;
                    //道菜基准数量
                    row.SuitQuantity = suit.Quantity;
                    //道菜基准加价
                    row.SuitAddPrice = suit.AddPrice;
                    //道菜基准加价 = 主菜数量 * 道菜基准单价
                    row.SuitAmount = master.Quantity * suit.AddPrice;

                    //界面-优惠列显示
                    row.Discount = 0;
                    //界面-行下划线
                    row.Underline = (++inx) == lists.Count ? 1 : 0;
                    //界面-是否有做法
                    row.Flavor = 0;

                    //当前行父ID
                    row.ParentId = master.Id;
                    //当前行分组
                    row.Group = master.Group;
                    //加料
                    row.Scheme = "";

                    //道菜数量随主菜数量变化
                    row.Quantity = master.Quantity * row.SuitQuantity;

                    rows.Add(row);
                }

                //套餐价格分摊
                PromotionUtils.CalculateSuitShare(orderObject, rows);

            }

            return rows;
        }

        /// <summary>
        /// 添加会员优惠
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="item"></param>
        public void AddMemberPromotion(OrderObject orderObject, OrderItem item)
        {
            //会员价优惠
            if (orderObject.IsMember == 1 || orderObject.IsUserMemberPrice)
            {
                //享受会员优惠的前提是 1、没有整单优惠  2、单品没有享受优惠
                bool isGo = true;
                if (isGo && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                {
                    isGo = false;
                }

                if (isGo && item.Promotions != null && item.Promotions.Count > 0)
                {
                    if (item.Promotions.Exists(x => x.PromotionType != PromotionType.会员价))
                    {
                        //已经存在其他优惠的不能享受会员优惠
                        isGo = false;
                    }
                }

                //验证会员价是否优惠了
                if (isGo && item.MemberPrice == item.Price)
                {
                    //会员价不优惠，不添加促销，方便进行其他促销
                    isGo = false;
                }

                //会员等级设置禁止享受会员价，2020-08-17 Add zhangy 
                if (isGo && orderObject.IsMember == 1 && orderObject.Member.MemberPriceFlag == 0)
                {
                    isGo = false;
                }

                //强制使用会员价，2020-08-19 Add zhangy 
                if (orderObject.IsUserMemberPrice)
                {
                    isGo = true;
                }
                //使用会员卡
                //是否存在优惠
                if (isGo)
                {
                    //订单不存在优惠
                    //会员价优惠
                    var promotion = new PromotionItem();
                    //标识
                    promotion.Id = IdWorkerUtils.Instance.NextId();
                    //租户ID
                    promotion.TenantId = item.TenantId;
                    //订单ID
                    promotion.OrderId = item.OrderId;
                    //订单编号
                    promotion.TradeNo = item.TradeNo;
                    //单品编号
                    promotion.ItemId = item.Id;
                    //类型
                    promotion.PromotionType = PromotionType.会员价;
                    //折扣率
                    if (item.Price != 0)
                    {
                        promotion.DiscountRate = OrderUtils.ToRound(item.MemberPrice / item.Price);
                    }
                    else
                    {
                        promotion.DiscountRate = 0;
                    }

                    PromotionUtils.Calculate(orderObject, item, promotion);
                    //刷新优惠金额
                    item.Discount = item.DiscountAmount;
                }
            }

        }


        /// <summary>
        /// 添加商品优惠券
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="item"></param>
        public void AddProductCouponPromotion(OrderObject orderObject, OrderItem item, PromotionEntity fineProm)
        {
            //享受单品优惠的前提是 1、没有整单优惠 2、没有享受过会员价、商品券以外的优惠
            bool isGo = true;

            if (isGo && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
            {
                isGo = false;
            }
            if (item.Promotions != null && item.Promotions.Count > 0)
            {
                if (item.Promotions.Exists(x => x.PromotionType != PromotionType.会员价 && x.PromotionType != PromotionType.商品优惠券))
                {
                    //已经存在其他优惠的不能享受商品优惠券优惠
                    isGo = false;
                }
            }
            //如果存在代金券优惠先移除掉原来的代金券
            var promotionList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.商品优惠券);
            if (promotionList != null)
            {
                foreach (PromotionItem promotion in promotionList)
                {
                    item.Promotions.Remove(promotion);
                }
                //重新算折扣价
                item.DiscountPrice = OrderUtils.ToRound((item.Amount - item.DiscountAmount) / item.Quantity);
                PromotionUtils.UpdateSuitMain(orderObject, item);
                //套餐道菜分摊
                PromotionUtils.CalculateSuitShare(orderObject, item);
            }
            //是否存在优惠
            if (isGo)
            {
                //订单不存在优惠
                //会员价优惠
                var promotion = new PromotionItem();
                //标识
                promotion.Id = IdWorkerUtils.Instance.NextId();
                //租户ID
                promotion.TenantId = item.TenantId;
                //订单ID
                promotion.OrderId = item.OrderId;
                //订单编号
                promotion.TradeNo = item.TradeNo;
                //单品编号
                promotion.ItemId = item.Id;
                //类型
                promotion.PromotionType = PromotionType.商品优惠券;
                //优惠金额
                if (item.DiscountPrice >= fineProm.DiscountAmount)
                {
                    promotion.DiscountAmount = fineProm.DiscountAmount * item.Quantity;
                }
                else
                {
                    promotion.DiscountAmount = item.DiscountPrice * item.Quantity;
                }
                //折扣率
                if (item.Price != 0)
                {
                    promotion.DiscountRate = OrderUtils.ToRound(fineProm.DiscountAmount / (item.Price * item.Quantity));
                }
                else
                {
                    promotion.DiscountRate = 0;
                }

                PromotionUtils.Calculate(orderObject, item, promotion);
                //刷新优惠金额
                item.Discount = item.DiscountAmount;
            }
        }

        /// <summary>
        /// 添加会员等级优惠
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="item"></param>
        public void AddMemberLevelPromotion(OrderObject orderObject, OrderItem item, PromotionEntity fineProm)
        {
            //会员等级优惠
            if (orderObject.IsMember == 1)
            {
                //享受会员等级优惠的前提是 1、没有整单优惠  2、单品没有享受优惠
                bool isGo = true;
                if (isGo && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                {
                    isGo = false;
                }

                if (item.Promotions != null && item.Promotions.Count > 0)
                {
                    if (item.Promotions.Exists(x => x.PromotionType != PromotionType.会员等级优惠))
                    {
                        //已经存在其他优惠的不能享受会员优惠
                        isGo = false;
                    }
                }
                //验证会员等级不优惠
                if (fineProm.DiscountAmount == 0)
                {
                    //会员等级不优惠，不添加促销，方便进行其他促销
                    isGo = false;
                }
                //使用会员卡
                //是否存在优惠
                if (isGo)
                {
                    //订单不存在优惠
                    //会员价优惠
                    var promotion = new PromotionItem();
                    //标识
                    promotion.Id = IdWorkerUtils.Instance.NextId();
                    //租户ID
                    promotion.TenantId = item.TenantId;
                    //订单ID
                    promotion.OrderId = item.OrderId;
                    //订单编号
                    promotion.TradeNo = item.TradeNo;
                    //单品编号
                    promotion.ItemId = item.Id;
                    //类型
                    promotion.PromotionType = PromotionType.会员等级优惠;
                    //优惠金额
                    promotion.DiscountAmount = fineProm.DiscountAmount;
                    //折扣率
                    if (item.Price != 0)
                    {
                        promotion.DiscountRate = OrderUtils.ToRound(fineProm.DiscountAmount / (item.Price * item.Quantity));
                    }
                    else
                    {
                        promotion.DiscountRate = 0;
                    }

                    PromotionUtils.Calculate(orderObject, item, promotion);
                    //刷新优惠金额
                    item.Discount = item.DiscountAmount;
                }
            }

        }

        /// <summary>
        /// 取消会员优惠
        /// </summary>
        /// <param name="orderObject"></param>
        public void RemoveMemberPromotion(OrderObject orderObject)
        {
            //取消整单会员优惠
            if (orderObject.Promotions != null)
            {
                List<PromotionOrder> promotionList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.卡友日 || x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券);
                if (promotionList != null)
                {
                    foreach (PromotionOrder promotion in promotionList)
                    {
                        orderObject.Promotions.Remove(promotion);
                    }
                }

                //过滤只有会员才能享受的满减、商品特价等优惠
                List<PromotionOrder> proList = new List<PromotionOrder>();
                foreach (var prom in orderObject.Promotions)
                {
                    if (!string.IsNullOrEmpty(prom.PlanNo))
                    {
                        var res = PromotionEngine.Instance.PromotionTasks.FirstOrDefault(x => x.PromotionSn == prom.PlanNo);
                        if (res != null && res.IsOnlyMember == 1)
                        {
                            proList.Add(prom);
                        }
                    }
                }

                foreach (var rePro in proList)
                {
                    orderObject.Promotions.Remove(rePro);
                }
            }

            //取消单品会员优惠
            foreach (var item in orderObject.Items)
            {
                if (item.Promotions != null)
                {
                    var promotionList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.会员价 || x.PromotionType == PromotionType.卡友日 || x.PromotionType == PromotionType.会员等级优惠 || x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券 || x.PromotionType == PromotionType.电子兑换券);
                    if (promotionList != null)
                    {
                        foreach (PromotionItem promotion in promotionList)
                        {
                            item.Promotions.Remove(promotion);
                        }
                    }

                    //过滤只有会员才能享受的满减、商品特价等优惠
                    List<PromotionItem> proList = new List<PromotionItem>();
                    foreach (var prom in item.Promotions)
                    {
                        if (!string.IsNullOrEmpty(prom.PlanNo))
                        {
                            var res = PromotionEngine.Instance.PromotionTasks.FirstOrDefault(x => x.PromotionSn == prom.PlanNo);
                            if (res != null && res.IsOnlyMember == 1)
                            {
                                proList.Add(prom);
                            }
                        }
                    }

                    foreach (var rePro in proList)
                    {
                        item.Promotions.Remove(rePro);
                    }
                }
            }
        }


        /// <summary>
        /// 是否包含会员促销
        /// </summary>
        /// <param name="orderObject"></param>
        public bool HavMemberPromotion(OrderObject orderObject)
        {
            //取消整单会员优惠
            if (orderObject.Promotions != null)
            {
                List<PromotionOrder> promotionList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.卡友日 || x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券);
                if (promotionList != null)
                {
                    return true;
                }
            }

            //取消单品会员优惠
            foreach (var item in orderObject.Items)
            {
                if (item.Promotions != null)
                {
                    var promotionList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.会员价 || x.PromotionType == PromotionType.卡友日 || x.PromotionType == PromotionType.会员等级优惠 || x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券 || x.PromotionType == PromotionType.电子兑换券);
                    if (promotionList != null)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 取消会员优惠
        /// </summary>
        /// <param name="orderObject"></param>
        public bool HavMemberPromotionCoup(OrderObject orderObject)
        {
            //取消整单会员优惠
            if (orderObject.Promotions != null)
            {
                List<PromotionOrder> promotionList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券);
                if (promotionList != null && promotionList.Count > 0)
                {
                    return true;
                }
            }

            //取消单品会员优惠
            foreach (var item in orderObject.Items)
            {
                if (item.Promotions != null)
                {
                    var promotionList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券 || x.PromotionType == PromotionType.电子兑换券);
                    if (promotionList != null && promotionList.Count > 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 构建手工做法对象
        /// </summary>
        /// <param name="orderItem"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public FlavorItem BuildHandFlavor(OrderItem orderItem, string name)
        {
            FlavorItem flavor = new FlavorItem();

            flavor.Id = IdWorkerUtils.Instance.NextId();

            //做法单选或者多选情况下的Key
            flavor.Group = flavor.Id;
            flavor.TenantId = orderItem.TenantId;
            flavor.TradeNo = orderItem.TradeNo;

            flavor.OrderId = orderItem.OrderId;
            flavor.ItemId = orderItem.Id;

            flavor.Name = name;
            flavor.MakeId = flavor.Id;
            flavor.Code = "000";
            flavor.QtyFlag = 1;
            flavor.Price = 0.00M;


            flavor.Type = 0;
            flavor.IsRadio = 1;
            flavor.Hand = 1;

            //基准数量
            flavor.BaseQuantity = 1;

            flavor.OrderItemQuantity = orderItem.WeighFlag == 1 ? 1.00M : orderItem.Quantity;

            return flavor;
        }
        #region 食堂版-订单操作前校验
        /// <summary>
        /// 订单操作前校验
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        public Tuple<bool, string> STB_MenuOperateValidate(OrderObject orderObject, OrderItem orderItem, string keyData)
        {
            // 第一步，菜单是否为操作当前订单，不是则放行，是则校验当前订单是否还允许操作
            var result = STB_BeforeOrderObjectOperateValidateStep1(orderObject, orderItem, keyData);
            return result;
        }
        /// <summary>
        /// 第一步，食堂版校验按钮规则
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        public Tuple<bool, string> STB_BeforeOrderObjectOperateValidateStep1(OrderObject orderObject, OrderItem orderItem, string keyData)
        {
            //订单交易完成，系统显示已结账,快速结账禁用
            bool result = true;
            string message = "校验通过";
            //部分功能存在校验特例
            switch (keyData)
            {
                case "上一页":
                case "下一页":
                case "功能":
                case "交班":
                case "注销":
                case "锁屏":
                case "最小化":
                case "退出":
                    {
                        result = true;
                    }
                    break;
                default:
                    {
                        if (result && orderObject == null)
                        {
                            result = false;
                            message = "请取消订单后重新点单";
                        }
                        //订单交易完成，系统显示已结账,快速结账禁用
                        if (result && ((orderObject.OrderType == OrderType.电话外卖 && orderObject.OrderStatus == OrderStatus.等待付款) || orderObject.OrderStatus == OrderStatus.已完成))
                        {
                            result = false;
                            message = "不支持的操作,交易已结账";
                        }

                        //是否有点单记录存在
                        if (result && orderObject.Items.Count == 0)
                        {
                            result = false;
                            message = "请先点单";
                        }

                        ////是否有选择的商品
                        //if (result && orderItem == null)
                        //{
                        //    result = false;
                        //    message = "请选择要操作的商品";
                        //}
                    }
                    break;
            }

            return new Tuple<bool, string>(result, message);
        }

        #endregion

        #region 订单操作前校验
        /// <summary>
        /// 订单操作前校验
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        public Tuple<bool, string> MenuOperateValidate(OrderObject orderObject, OrderItem orderItem, string keyCode)
        {
            // 第一步，菜单是否为操作当前订单，不是则放行，是则校验当前订单是否还允许操作
            var result = BeforeOrderObjectOperateValidateStep1(orderObject, orderItem, keyCode);
            if (result.Item1)
            {
                //第二步，菜单操作是否违反具体业务规则
                result = BeforeOrderObjectOperateValidateStep2(orderObject, orderItem, keyCode);
            }
            return result;
        }


        /// <summary>
        /// 第一步，菜单是否为操作当前订单，不是则放行，是则校验当前订单是否还允许操作
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        public Tuple<bool, string> BeforeOrderObjectOperateValidateStep1(OrderObject orderObject, OrderItem orderItem, string keyCode)
        {
            //订单交易完成，系统显示已结账,快速结账禁用

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

            bool result = true;
            string message = "校验通过";
            //部分功能存在校验特例
            switch (_keyCode)
            {
                case ModuleKeyCode.销售流水:
                case ModuleKeyCode.销售汇总:
                case ModuleKeyCode.收银报表:
                case ModuleKeyCode.营业日报:
                case ModuleKeyCode.时段报表:
                case ModuleKeyCode.交班查询:
                case ModuleKeyCode.外卖汇总:
                case ModuleKeyCode.外送汇总:
                case ModuleKeyCode.优惠明细:
                case ModuleKeyCode.操作监控:
                case ModuleKeyCode.经营会计报表:
                case ModuleKeyCode.单品日销售汇总:
                case ModuleKeyCode.交班:
                case ModuleKeyCode.非营业收入:
                case ModuleKeyCode.非营业支出:
                case ModuleKeyCode.备用金:
                case ModuleKeyCode.取消全单:
                case ModuleKeyCode.会员:
                case ModuleKeyCode.开钱箱:
                case ModuleKeyCode.登录密码:
                case ModuleKeyCode.挂单:
                case ModuleKeyCode.取单:
                case ModuleKeyCode.外带:
                case ModuleKeyCode.清零:
                case ModuleKeyCode.去皮:
                case ModuleKeyCode.美团订单://310
                case ModuleKeyCode.沽清:
                case ModuleKeyCode.云参数上传://146
                case ModuleKeyCode.微信订单:
                case ModuleKeyCode.QM小程序订单://307
                case ModuleKeyCode.GC小程序订单://308
                case ModuleKeyCode.百度外卖:
                case ModuleKeyCode.饿了么:
                case ModuleKeyCode.美团外卖:
                case ModuleKeyCode.微信商品管理://306
                case ModuleKeyCode.卡消费汇总://419
                case ModuleKeyCode.会员卡开户://401
                case ModuleKeyCode.会员卡充值://402
                case ModuleKeyCode.礼品卡销售://403
                case ModuleKeyCode.会员查询://404
                case ModuleKeyCode.修改卡密码://405
                case ModuleKeyCode.会员退卡://406
                case ModuleKeyCode.积分兑换://407
                case ModuleKeyCode.积分合并://408
                case ModuleKeyCode.门店消费查询://409
                case ModuleKeyCode.金额变动历史://410
                case ModuleKeyCode.积分变动历史://411
                case ModuleKeyCode.会员换卡://413
                case ModuleKeyCode.门店会员查询://414
                case ModuleKeyCode.充值记录查询://414
                case ModuleKeyCode.会员日志://415
                case ModuleKeyCode.礼品卡销售记录://416
                case ModuleKeyCode.密码重置://417
                case ModuleKeyCode.卡券核销记录://418
                case ModuleKeyCode.会员信息变更://420
                case ModuleKeyCode.微会员绑卡://421
                case ModuleKeyCode.自定义充值://422
                case ModuleKeyCode.要货单://701
                case ModuleKeyCode.入库单://702
                case ModuleKeyCode.配送验收://703
                case ModuleKeyCode.库存盘点://704
                case ModuleKeyCode.库存查询://705
                case ModuleKeyCode.报损单://706
                case ModuleKeyCode.耗料单://707
                case ModuleKeyCode.要货账户://708
                case ModuleKeyCode.要货充值://709
                case ModuleKeyCode.账单查询://710
                case ModuleKeyCode.发票申请://711
                case ModuleKeyCode.商品耗料://711
                case ModuleKeyCode.代金券://10017
                case ModuleKeyCode.美团券://10064
                case ModuleKeyCode.美团券核销://10064
                case ModuleKeyCode.桌台汇总:
                case ModuleKeyCode.会员合并:
                case ModuleKeyCode.熟客信息:
                case ModuleKeyCode.积分兑换明细:
                case ModuleKeyCode.积分冲减:
                    {
                        result = true;
                    }
                    break;

                default:
                    {
                        if (result && orderObject == null)
                        {
                            result = false;
                            message = "请取消订单后重新点单";
                        }
                        //订单交易完成，系统显示已结账,快速结账禁用
                        if (result && ((orderObject.OrderType == OrderType.电话外卖 && orderObject.OrderStatus == OrderStatus.等待付款) || orderObject.OrderStatus == OrderStatus.已完成))
                        {
                            result = false;
                            message = "不支持的操作,交易已结账";
                        }

                        //是否有点单记录存在
                        if (result && orderObject.Items.Count == 0)
                        {
                            result = false;
                            message = "请先点单";
                        }

                        //是否有选择的商品
                        if (result && orderItem == null)
                        {
                            result = false;
                            message = "请选择要操作的商品";
                        }
                    }
                    break;
            }

            return new Tuple<bool, string>(result, message);
        }

        /// <summary>
        /// 第二步，菜单操作是否违反具体业务规则
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        private Tuple<bool, string> BeforeOrderObjectOperateValidateStep2(OrderObject orderObject, OrderItem orderItem, string keyCode)
        {
            //订单交易完成，系统显示已结账,快速结账禁用

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

            bool result = true;
            string message = "校验通过";
            //部分功能存在校验特例
            switch (_keyCode)
            {
                case ModuleKeyCode.单品议价:
                    {
                        //禁止单品折扣套餐明细
                        if (orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "套餐明细不允许议价操作!";
                        }

                        //云端禁止议价
                        if (result && orderItem.CurrentFlag == 0)
                        {
                            result = false;
                            message = "不支持议价操作!";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }
                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                        //单品所属group是否已经享受优惠
                        if (result)
                        {
                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                            if (promGroupItems.Count > 0)
                            {
                                result = false;
                                var promItem = promGroupItems[0];
                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.整单议价:
                    {
                        //判断是否有不可议价的商品，1）不可议价；2)不是套餐明细
                        if (orderObject.Items.Count(x => x.CurrentFlag == 0 && x.RowState != OrderRowState.套餐明) > 0)
                        {
                            result = false;
                            message = "有不支持议价的商品，请单品议价!";
                        }
                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }
                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                    }
                    break;
                case ModuleKeyCode.议价:
                    {
                        var notAllowBargain = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_BARGAIN, false);
                        //禁止收银前台议价
                        if (result && notAllowBargain)
                        {
                            result = false;
                            message = "禁止收银前台议价!";
                        }

                        //禁止单品折扣套餐明细
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "套餐明细不允许议价操作!";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                        //单品所属group是否已经享受优惠
                        if (result)
                        {
                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                            if (promGroupItems.Count > 0)
                            {
                                result = false;
                                var promItem = promGroupItems[0];
                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.整单折扣:
                case ModuleKeyCode.单品折扣:
                    {
                        var notAllowDiscount = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_DISCOUNT, false);
                        //禁止收银前台折扣
                        if (result && notAllowDiscount)
                        {
                            result = false;
                            message = "禁止收银前台折扣!";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }


                        if (result && _keyCode == ModuleKeyCode.单品折扣)
                        {
                            //云端禁止折扣
                            if (orderItem.DiscountFlag == 0)
                            {
                                result = false;
                                message = "不支持折扣操作!";
                            }

                            //有单品优惠禁止操作
                            if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                            {
                                result = false;
                                message = "享受过优惠，不允许操作";
                            }

                            //禁止单品折扣套餐明细
                            if (orderItem.RowState == OrderRowState.套餐明)
                            {
                                result = false;
                                message = "套餐明细不允许折扣操作!";
                            }

                            //单品所属group是否已经享受优惠
                            if (result)
                            {
                                var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                                if (promGroupItems.Count > 0)
                                {
                                    result = false;
                                    var promItem = promGroupItems[0];
                                    message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                                }
                            }
                        }


                        if (result && _keyCode == ModuleKeyCode.整单折扣)
                        {
                            //判断是否有可折扣的商品，1）可折扣；2)不是套餐明细
                            if (orderObject.Items.Count(x => x.DiscountFlag == 1 && x.RowState != OrderRowState.套餐明) == 0)
                            {
                                result = false;
                                message = "没有可折扣的单品!";
                            }

                            if (result)
                            {
                                foreach (var item in orderObject.Items)
                                {
                                    //有单品优惠禁止操作
                                    if (item.Promotions != null && item.Promotions.FindAll(x => x.PromotionType != PromotionType.道菜分摊).Count > 0)
                                    {
                                        result = false;
                                        message = "单品享受过优惠，不允许操作";

                                        break;
                                    }
                                }
                            }
                        }
                    }
                    break;

                case ModuleKeyCode.整单定额优惠:
                case ModuleKeyCode.单品定额优惠:
                case ModuleKeyCode.整单定率折扣:
                case ModuleKeyCode.单品定率折扣:
                    {
                        var notAllowDiscount = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_DISCOUNT, false);
                        //禁止收银前台折扣
                        if (result && notAllowDiscount)
                        {
                            result = false;
                            message = "禁止收银前台折扣!";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }


                        if (result)
                        {
                            switch (_keyCode)
                            {
                                case ModuleKeyCode.单品定额优惠:
                                case ModuleKeyCode.单品定率折扣:
                                    {
                                        //云端禁止折扣
                                        if (orderItem.DiscountFlag == 0)
                                        {
                                            result = false;
                                            message = "不支持折扣操作!";
                                        }

                                        //有单品优惠禁止操作
                                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                                        {
                                            result = false;
                                            message = "享受过优惠，不允许操作";
                                        }

                                        //禁止单品折扣套餐明细
                                        if (orderItem.RowState == OrderRowState.套餐明)
                                        {
                                            result = false;
                                            message = "套餐明细不允许折扣操作!";
                                        }

                                        //单品所属group是否已经享受优惠
                                        if (result)
                                        {
                                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                                            if (promGroupItems.Count > 0)
                                            {
                                                result = false;
                                                var promItem = promGroupItems[0];
                                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                                            }
                                        }
                                    }
                                    break;
                                case ModuleKeyCode.整单定额优惠:
                                case ModuleKeyCode.整单定率折扣:
                                    {
                                        //判断是否有可折扣的商品，1）可折扣；2)不是套餐明细
                                        if (orderObject.Items.Count(x => x.DiscountFlag == 1 && x.RowState != OrderRowState.套餐明) == 0)
                                        {
                                            result = false;
                                            message = "没有可折扣的单品!";
                                        }

                                        if (result)
                                        {
                                            foreach (var item in orderObject.Items)
                                            {
                                                //有单品优惠禁止操作
                                                if (item.Promotions != null && item.Promotions.FindAll(x => x.PromotionType != PromotionType.道菜分摊).Count > 0)
                                                {
                                                    result = false;
                                                    message = "单品享受过优惠，不允许操作";

                                                    break;
                                                }
                                            }
                                        }
                                    }
                                    break;
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.折扣:
                    {
                        var notAllowDiscount = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_DISCOUNT, false);
                        //禁止收银前台折扣
                        if (result && notAllowDiscount)
                        {
                            result = false;
                            message = "禁止收银前台折扣!";
                        }

                        //禁止单品折扣套餐明细
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "套餐明细不允许折扣操作!";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                        //单品所属group是否已经享受优惠
                        if (result)
                        {
                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                            if (promGroupItems.Count > 0)
                            {
                                result = false;
                                var promItem = promGroupItems[0];
                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.单品赠送:
                case ModuleKeyCode.赠送:
                    {
                        var notAllowGive = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_GIVE, false);
                        //禁止收银前台赠送
                        if (result && notAllowGive)
                        {
                            result = false;
                            message = "禁止收银前台赠送!";
                        }

                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许赠送套餐明细!";
                        }

                        //后台设置不允许赠送
                        if (result && orderItem.GiveFlag == 0)
                        {
                            result = false;
                            message = "不允许赠送操作";
                        }

                        //有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                        //单品所属group是否已经享受优惠
                        if (result)
                        {
                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Promotions != null && x.Promotions.Count > 0);
                            if (promGroupItems.Count > 0)
                            {
                                result = false;
                                var promItem = promGroupItems[0];
                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                            }
                        }
                    }
                    break;
                case ModuleKeyCode.换菜:
                    {
                        if (result && (orderItem.RowState != OrderRowState.套餐明 && orderItem.RowState != OrderRowState.套餐主))
                        {
                            result = false;
                            message = "不是套餐，不允许操作";
                        }


                        //如果有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //if (result && orderItem.RowState == OrderRowState.套餐明)
                        //{
                        //    //查找套餐主，如果套餐主享受优惠，不允许套餐明细操作
                        //    var master = orderObject.Items.Find(x => x.Id == orderItem.ParentId);

                        //    //有单品优惠禁止操作
                        //    if (result && master.Promotions != null && master.Promotions.Count > 0)
                        //    {
                        //        result = false;
                        //        message = "套餐已优惠，不允许操作";
                        //    }
                        //}
                        //else
                        //{
                        //    //有单品优惠禁止操作
                        //    if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        //    {
                        //        result = false;
                        //        message = "享受过优惠，不允许操作";
                        //    }
                        //}
                    }
                    break;
                case ModuleKeyCode.规格:
                    {
                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许调整套餐明细的规格!";
                        }

                        //如果有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //单品所属group是否已经享受优惠
                        if (result)
                        {
                            var promGroupItems = orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明 && x.Group == orderItem.Group && x.Id != orderItem.Id && x.Promotions != null && x.Promotions.Count > 0);
                            if (promGroupItems.Count > 0)
                            {
                                result = false;
                                var promItem = promGroupItems[0];
                                message = string.Format("<{0}>享受过关联优惠，不允许操作", promItem.Name);
                            }
                        }

                        //有单品优惠禁止操作
                        //if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        //{
                        //    if(orderItem.Promotions.Exists(x => x.PromotionType != PromotionType.会员价))
                        //    {
                        //        //享受过会员价以外的优惠，不能切换规格
                        //        result = false;
                        //        message = "享受过优惠，不允许操作";
                        //    }
                        //}
                    }
                    break;
                case ModuleKeyCode.要求:
                    {
                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐主)
                        {
                            result = false;
                            message = "不允许的操作!";
                        }

                        //如果有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许操作";
                        }

                        //if (result && orderItem.RowState == OrderRowState.套餐明)
                        //{
                        //    //查找套餐主，如果套餐主享受优惠，不允许套餐明细操作
                        //    var master = orderObject.Items.Find(x => x.Id == orderItem.ParentId);

                        //    //有单品优惠禁止操作
                        //    if (result && master.Promotions != null && master.Promotions.Count > 0)
                        //    {
                        //        if (orderItem.Promotions.Exists(x => x.PromotionType != PromotionType.会员价))
                        //        {
                        //            //享受过会员价以外的优惠，不能切换规格
                        //            result = false;
                        //            message = "套餐已优惠，不允许操作";
                        //        }
                        //    }
                        //}
                        //else
                        //{
                        //有单品优惠禁止操作
                        //if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        //{
                        //    if (orderItem.Promotions.Exists(x => x.PromotionType != PromotionType.会员价))
                        //    {
                        //        //享受过会员价以外的优惠，不能切换规格
                        //        result = false;
                        //        message = "享受过优惠，不允许操作";
                        //    }
                        //}
                        //}
                    }
                    break;
                case ModuleKeyCode.数量减:
                    {
                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许调整套餐明细的数量!";
                        }

                        //如果有整单优惠，禁止操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许调整数量";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                    }
                    break;
                case ModuleKeyCode.数量加:
                    {
                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许调整套餐明细的数量!";
                        }

                        //如果有整单优惠，禁止点单操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许调整数量";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                    }
                    break;
                case ModuleKeyCode.数量:
                    {
                        //套餐明细禁止操作
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许调整套餐明细的数量!";
                        }

                        //如果有整单优惠，禁止点单操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许调整数量";
                        }

                        //有单品优惠禁止操作
                        if (result && orderItem.Promotions != null && orderItem.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受过优惠，不允许操作";
                        }
                    }
                    break;
                case ModuleKeyCode.删除单品:
                    {
                        if (result && orderItem.RowState == OrderRowState.套餐明)
                        {
                            result = false;
                            message = "不允许调整套餐明细的数量!";
                        }

                        //如果有整单优惠，禁止点单操作
                        if (result && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许删除操作";
                        }

                        //享受关联优惠
                        if (result && !string.IsNullOrEmpty(orderItem.ParentId))
                        {
                            result = false;
                            message = "享受关联优惠，不允许删除操作";
                        }

                    }
                    break;
                case ModuleKeyCode.挂单:
                    {
                        //练习模式
                        if (Global.Instance.IsStudyMode())
                        {
                            result = false;
                            message = "练习模式！不允许操作！";
                        }
                        if (false && orderObject.Promotions != null && orderObject.Promotions.Count > 0)
                        {
                            result = false;
                            message = "享受整单优惠，不允许挂单操作";
                        }
                    }
                    break;
                case ModuleKeyCode.外带:
                    {
                        if (result && orderObject == null)
                        {
                            result = false;
                            message = "请取消订单后重新点单";
                        }
                        //订单交易完成，系统显示已结账,快速结账禁用
                        if (result && ((orderObject.OrderType == OrderType.电话外卖 && orderObject.OrderStatus == OrderStatus.等待付款) || orderObject.OrderStatus == OrderStatus.已完成))
                        {
                            result = false;
                            message = "不支持的操作,交易已结账";
                        }
                    }
                    break;
                case ModuleKeyCode.交班:
                case ModuleKeyCode.代金券:
                case ModuleKeyCode.会员:
                case ModuleKeyCode.会员卡充值:
                case ModuleKeyCode.会员卡开户:
                case ModuleKeyCode.会员退卡:
                case ModuleKeyCode.修改卡密码:
                case ModuleKeyCode.入库单:
                case ModuleKeyCode.发票申请:
                case ModuleKeyCode.取单:
                case ModuleKeyCode.备用金:
                case ModuleKeyCode.库存盘点:
                case ModuleKeyCode.报损单:
                case ModuleKeyCode.沽清:
                case ModuleKeyCode.礼品卡销售:
                case ModuleKeyCode.积分兑换:
                case ModuleKeyCode.积分合并:
                case ModuleKeyCode.耗料单:
                case ModuleKeyCode.要货充值:
                case ModuleKeyCode.要货单:
                case ModuleKeyCode.要货账户:
                case ModuleKeyCode.配送验收:
                case ModuleKeyCode.非营业支出:
                case ModuleKeyCode.非营业收入:
                case ModuleKeyCode.门店外卖:
                case ModuleKeyCode.外送汇总:
                    {
                        //练习模式
                        if (Global.Instance.IsStudyMode())
                        {
                            result = false;
                            message = "练习模式！不允许操作！";
                        }
                    }
                    break;
            }
            return new Tuple<bool, string>(result, message);
        }

        #endregion

        #region 订单优惠计算

        /// <summary>
        /// 取消整单优惠
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public bool RemoveOrderPromotion(OrderObject orderObject)
        {
            orderObject.Promotions = null;
            orderObject.Promotions = new List<PromotionOrder>();
            foreach (var item in orderObject.Items)
            {
                item.Promotions = null;
                item.Promotions = new List<PromotionItem>();
                item.DiscountPrice = item.Price;
                item.Discount = 0.00M;
                foreach (FlavorItem flavorItem in item.Flavors)
                {
                    flavorItem.DiscountPrice = flavorItem.Price;
                    flavorItem.DiscountAmount = 0;
                }
                //套餐主、普通菜有parentId证明是优惠关联了，取消优惠，解除关联
                //if(item.RowState != OrderRowState.套餐明 && !string.IsNullOrEmpty(item.ParentId))
                //{
                //    item.ParentId = null;
                //}
            }
            // 如果包含套餐优惠分摊
            foreach (var item in orderObject.Items)
            {
                if (item.RowState == OrderRowState.套餐主)
                {
                    PromotionUtils.CalculateSuitShare(orderObject, item);
                }
            }
            return true;
        }

        /// <summary>
        /// 取消单品优惠
        /// </summary>
        /// <param name="order"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        public List<OrderItem> RemoveOrderItemPromotion(OrderObject order, OrderItem item)
        {
            List<OrderItem> itemList = new List<OrderItem>();

            item.Promotions = null;
            item.Promotions = new List<PromotionItem>();
            item.DiscountPrice = item.Price;
            item.Discount = 0.00M;
            itemList.Add(item);

            //找关联优惠，同步取消
            var subItems = order.Items.FindAll(x => x.ParentId == item.Id && x.RowState != OrderRowState.套餐明);

            foreach (var sub in subItems)
            {
                sub.Promotions = null;
                sub.Promotions = new List<PromotionItem>();
                sub.DiscountPrice = item.Price;
                sub.Discount = 0.00M;
                sub.ParentId = null;
                itemList.Add(sub);
            }
            return itemList;
        }

        /// <summary>
        /// 赠送
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        public void OrderItemGive(OrderObject orderObject, OrderItem orderItem)
        {
            //单品赠送
            var promotion = new PromotionItem();
            //标识
            promotion.Id = IdWorkerUtils.Instance.NextId();
            //租户ID
            promotion.TenantId = orderItem.TenantId;
            //订单ID
            promotion.OrderId = orderItem.OrderId;
            //订单编号
            promotion.TradeNo = orderItem.TradeNo;
            //单品编号
            promotion.ItemId = orderItem.Id;
            //类型
            promotion.PromotionType = PromotionType.赠送;
            //折扣率
            promotion.DiscountRate = 1;

            //优惠前金额
            promotion.Amount = orderItem.Amount;
            //优惠金额
            promotion.DiscountAmount = orderItem.Amount;
            //优惠后金额
            promotion.ReceivableAmount = 0;

            //优惠生效
            promotion.Enabled = false;

            //重新计算优惠
            PromotionUtils.Calculate(orderObject, orderItem, promotion);

            //套餐道菜分摊
            PromotionUtils.CalculateSuitShare(orderObject, orderItem);

            orderItem.Action = "单品赠送操作";
        }
        /// <summary>
        /// 商品电子兑换券计算
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        public void OrderItemProductGift(OrderObject orderObject, string couponId, string planNo, string planName, OrderItem orderItem)
        {
            //单品赠送
            var promotion = new PromotionItem();
            //标识
            promotion.Id = IdWorkerUtils.Instance.NextId();
            //租户ID
            promotion.TenantId = orderItem.TenantId;
            //订单ID
            promotion.OrderId = orderItem.OrderId;
            //订单编号
            promotion.TradeNo = orderItem.TradeNo;
            //单品编号
            promotion.ItemId = orderItem.Id;
            //类型
            promotion.PromotionType = PromotionType.电子兑换券;
            //折扣率
            promotion.DiscountRate = 1;

            //优惠前金额
            promotion.Amount = orderItem.Amount;
            //优惠金额
            promotion.DiscountAmount = orderItem.Amount;
            //优惠后金额
            promotion.ReceivableAmount = 0;

            //优惠生效
            promotion.Enabled = false;
            //兑换券code
            promotion.PlanNo = planNo;
            //兑换券名称
            promotion.PlanName = planName;
            //兑换券ID
            promotion.CouponId = couponId;
            PromotionUtils.Calculate(orderObject, orderItem, promotion);
            orderItem.Action = "电子兑换券操作";
        }

        /// <summary>
        /// 商品电子券计算
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        public void OrderItemProductProduct(OrderObject orderObject, OrderItem orderItem, PromotionEntity fineProm)
        {
            //单品赠送
            var promotion = new PromotionItem();
            //标识
            promotion.Id = IdWorkerUtils.Instance.NextId();
            //租户ID
            promotion.TenantId = orderItem.TenantId;
            //订单ID
            promotion.OrderId = orderItem.OrderId;
            //订单编号
            promotion.TradeNo = orderItem.TradeNo;
            //单品编号
            promotion.ItemId = orderItem.Id;
            //类型
            promotion.PromotionType = PromotionType.电子商品券;
            //优惠前金额
            promotion.Amount = orderItem.Amount;
            //优惠金额
            promotion.DiscountAmount = fineProm.DiscountAmount;
            //优惠后金额
            promotion.ReceivableAmount = orderItem.Amount - fineProm.DiscountAmount;
            //折扣率
            promotion.DiscountRate = OrderUtils.ToRound(fineProm.DiscountAmount / orderItem.Amount); ;
            //优惠生效
            promotion.Enabled = false;
            //兑换券code
            promotion.PlanNo = fineProm.PromotionId;
            //兑换券名称
            promotion.PlanName = fineProm.PromotionDesc;
            //兑换券ID
            promotion.CouponId = fineProm.CouponId;
            PromotionUtils.Calculate(orderObject, orderItem, promotion);
            orderItem.Action = "电子兑换券操作";
        }

        public Tuple<bool, string, List<OrderItem>> OrderItemQuantityPlusEx(OrderObject orderObject, OrderItem orderItem)
        {
            //添加沽清业务规则
            SaleClear saleClear = null;
            if (SaleClearUtils.Instance.Maps.ContainsKey(orderItem.ProductId))
            {
                saleClear = SaleClearUtils.Instance.Maps[orderItem.ProductId];
            }
            //是否参与沽清
            bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

            bool isSuccess = true;
            string message = "操作成功";
            List<OrderItem> refreshItems = new List<OrderItem>();

            try
            {
                //参与沽清，已经售完
                if (isSaleClear && saleClear.Quantity <= 0)
                {
                    isSuccess = false;
                    message = "沽清售完了";
                }

                //验证合法通过
                if (isSuccess)
                {
                    //每次添加都是第一次点单的数量为基础
                    orderItem.Quantity = orderItem.Quantity + 1;
                    //将更改后的行数据同步到订单列表
                    var inx = orderObject.Maps.IndexOf(orderItem);
                    orderObject.Maps[inx] = orderItem;

                    //判断是否是套餐主,同步更改套餐明细数量
                    if (orderItem.RowState == OrderRowState.套餐主)
                    {
                        var details = orderObject.Items.FindAll(x => x.ParentId == orderItem.Id && x.Group == orderItem.Group);
                        foreach (var item in details)
                        {
                            //道菜加价金额
                            item.SuitAmount = orderItem.Quantity * item.SuitAddPrice;

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

                            //将更改后的行数据同步到订单列表

                            var index = orderObject.Maps.IndexOf(item);
                            orderObject.Maps[index] = item;

                            refreshItems.Add(item);
                        }

                        //套餐道菜分摊
                        PromotionUtils.CalculateSuitShare(orderObject, orderItem);
                    }
                }
            }
            catch (Exception ex)
            {
                isSuccess = false;

                logger.Error(ex, "数量加一业务异常");
            }
            finally
            {
                if (isSuccess)
                {
                    if (isSaleClear)
                    {
                        saleClear.SaleQuantity += 1;

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

            return new Tuple<bool, string, List<OrderItem>>(isSuccess, message, refreshItems);

        }
        /// <summary>
        /// 商品数量加一
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <returns></returns>
        public List<OrderItem> OrderItemQuantityPlus(OrderObject orderObject, OrderItem orderItem)
        {
            //添加沽清业务规则
            SaleClear saleClear = null;
            if (SaleClearUtils.Instance.Maps.ContainsKey(orderItem.ProductId))
            {
                saleClear = SaleClearUtils.Instance.Maps[orderItem.ProductId];
            }
            //是否参与沽清
            bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

            bool isException = false;

            List<OrderItem> refreshItems = new List<OrderItem>();

            try
            {
                //每次添加都是第一次点单的数量为基础
                orderItem.Quantity = orderItem.Quantity + 1;
                //将更改后的行数据同步到订单列表
                var inx = orderObject.Maps.IndexOf(orderItem);
                orderObject.Maps[inx] = orderItem;

                //判断是否是套餐主,同步更改套餐明细数量
                if (orderItem.RowState == OrderRowState.套餐主)
                {
                    var details = orderObject.Items.FindAll(x => x.Group == orderItem.Group && x.ParentId == orderItem.Id);
                    foreach (var item in details)
                    {
                        //道菜加价金额
                        item.SuitAmount = orderItem.Quantity * item.SuitAddPrice;

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

                        //将更改后的行数据同步到订单列表

                        var index = orderObject.Maps.IndexOf(item);
                        orderObject.Maps[index] = item;

                        refreshItems.Add(item);
                    }

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(orderObject, orderItem);
                }
            }
            catch (Exception ex)
            {
                isException = true;

                logger.Error(ex, "数量减一业务异常");
            }
            finally
            {
                if (!isException)
                {
                    if (isSaleClear)
                    {
                        SaleClearUtils.Instance.Maps[orderItem.ProductId] = saleClear;
                    }
                }
            }

            return refreshItems;
        }

        /// <summary>
        /// 商品数量减一
        /// </summary>
        /// <param name="orderObject"></param>
        /// <param name="orderItem"></param>
        /// <returns></returns>
        public List<OrderItem> OrderItemQuantityMinus(OrderObject orderObject, OrderItem orderItem)
        {
            //添加沽清业务规则
            SaleClear saleClear = null;
            if (SaleClearUtils.Instance.Maps.ContainsKey(orderItem.ProductId))
            {
                saleClear = SaleClearUtils.Instance.Maps[orderItem.ProductId];
            }
            //是否参与沽清
            bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);


            bool isException = false;

            List<OrderItem> refreshItems = new List<OrderItem>();

            try
            {
                orderItem.Quantity = orderItem.Quantity - 1;
                if (orderItem.Quantity <= 0)
                {
                    orderItem.Quantity = 1;
                }
                else
                {
                    //沽清数量减 1
                    if (isSaleClear)
                    {
                        saleClear.SaleQuantity -= 1;
                    }
                }

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

                //判断是否是套餐主,同步更改套餐明细数量
                if (orderItem.RowState == OrderRowState.套餐主)
                {
                    var details = orderObject.Items.FindAll(x => x.Group == orderItem.Group && x.ParentId == orderItem.Id);
                    foreach (var item in details)
                    {
                        //道菜加价金额
                        item.SuitAmount = orderItem.Quantity * item.SuitAddPrice;

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

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

                        refreshItems.Add(item);

                    }

                    //套餐道菜分摊
                    PromotionUtils.CalculateSuitShare(orderObject, orderItem);
                }
            }
            catch (Exception ex)
            {
                isException = true;

                logger.Error(ex, "数量减一业务异常");
            }
            finally
            {
                if (!isException)
                {
                    if (isSaleClear)
                    {
                        SaleClearUtils.Instance.Maps[orderItem.ProductId] = saleClear;
                    }
                }
            }

            return refreshItems;
        }

        /// <summary>
        /// 后台促销新建促销记录
        /// </summary>
        /// <param name="subItem"></param>
        /// <param name="fineProm"></param>
        public void ApplyPromotionEntity(OrderObject orderObject, OrderItem subItem, PromotionEntity fineProm)
        {
            //商品促销优惠
            var promotion = new PromotionItem();
            //标识
            promotion.Id = IdWorkerUtils.Instance.NextId();
            //租户ID
            promotion.TenantId = subItem.TenantId;
            //订单ID
            promotion.OrderId = subItem.OrderId;
            //订单编号
            promotion.TradeNo = subItem.TradeNo;
            //单品编号
            promotion.ItemId = subItem.Id;
            //类型
            promotion.PromotionType = fineProm.Type;
            //方案
            promotion.PlanNo = fineProm.PromotionId;
            //方案名称
            promotion.PlanName = fineProm.Type.ToString();
            //优惠金额
            promotion.DiscountAmount = OrderUtils.ToRound(fineProm.DiscountAmount / fineProm.Products[0].Quantity * subItem.Quantity);
            //折扣率
            if (subItem.Amount != 0)
            {
                promotion.DiscountRate = OrderUtils.ToRound((subItem.Amount - promotion.DiscountAmount) / subItem.Amount);
            }
            else
            {
                promotion.DiscountRate = 0;
            }

            PromotionUtils.Calculate(orderObject, subItem, promotion);
            //优惠金额
            //subItem.Discount = subItem.DiscountAmount;
        }

        /// <summary>
        /// 双数特价优惠新增记录
        /// </summary>
        /// <param name="_orderObject"></param>
        /// <param name="_orderItem"></param>
        /// <param name="fineProm"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        public Tuple<bool, string, OrderItem> ApplyItemDoubleSpecialPromotion(OrderObject _orderObject, OrderItem _orderItem, PromotionEntity fineProm, decimal quantity)
        {
            //赠送商品
            OrderItem master = null;
            PromotionItem promotion = null;
            var products = fineProm.Products;
            foreach (var pro in products)
            {
                ProductExt product = null;
                using (var db = Global.Instance.OpenDataBase)
                {
                    var sql = string.Format(SqlConstant.ProductExt + " where p.id = '{0}' and s.id = '{1}';", pro.ProductId, pro.SpecId);
                    product = db.FirstOrDefault<ProductExt>(sql);
                }
                //沽清
                //创建新的
                //创建新的OrderItem
                master = BusinessUtils.Instance.NewOrderItem(_orderObject, product);
                master.Quantity = quantity;
                //商品促销优惠
                promotion = new PromotionItem();
                //标识
                promotion.Id = IdWorkerUtils.Instance.NextId();
                //租户ID
                promotion.TenantId = master.TenantId;
                //订单ID
                promotion.OrderId = master.OrderId;
                //订单编号
                promotion.TradeNo = master.TradeNo;
                //单品编号
                promotion.ItemId = master.Id;
                //类型
                promotion.PromotionType = fineProm.Type;
                //方案
                promotion.PlanNo = fineProm.PromotionId;
                //方案名称
                promotion.PlanName = fineProm.Type.ToString();
                //优惠金额
                promotion.DiscountAmount = OrderUtils.ToRound(fineProm.DiscountAmount / pro.Quantity * quantity);
                //折扣率
                if (master.Amount != 0)
                {
                    promotion.DiscountRate = OrderUtils.ToRound((master.Amount - promotion.DiscountAmount) / master.Amount);
                }
                else
                {
                    promotion.DiscountRate = 0;
                }

                PromotionUtils.Calculate(_orderObject, master, promotion);
                //优惠金额
                master.Discount = master.DiscountAmount;
                //依赖ID
                master.ParentId = _orderItem.Id;
            }

            return new Tuple<bool, string, OrderItem>(true, string.Empty, master);

        }

        /// <summary>
        /// 追加至目标行的行号
        /// </summary>
        /// <param name="order"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        public int AppendItemPosition(OrderObject order, OrderItem item)
        {
            int orderNo = item.OrderNo;
            if (item.RowState == OrderRowState.套餐主)
            {
                //套餐特殊处理，orderNo为套餐最后一道菜的序号
                var suitItem = order.Items.FindLast(x => x.Group == item.Group && x.RowState == OrderRowState.套餐明);
                if (suitItem != null)
                {
                    orderNo = suitItem.OrderNo;
                }
            }
            return orderNo;
        }

        /// <summary>
        /// 应用单品优惠
        /// </summary>
        /// <param name="fineProm"></param>
        /// <returns></returns>
        public bool ApplyItemFinePromotion(OrderObject _orderObject, OrderItem _orderItem, PromotionEntity fineProm)
        {
            bool needUpdate = false;

            switch (fineProm.Type)
            {
                case PromotionType.卡友日:
                    {
                        var pro = PromotionEngine.Instance.Promotions.Find(x => x.Type == PromotionType.卡友日.ToString());
                        if (pro != null)
                        {
                            var cont = JsonUtils.Deserialize<CardProDay>(pro.Content);
                            var discountValue = cont.DiscountValue;

                            // (0-按菜品 1-按整单)都按照整单计算比例
                            if (cont.ReferType == 0)
                            {
                                //按菜品
                                foreach (var orderItem in _orderObject.Items)
                                {
                                    if (orderItem.Promotions.Count > 0)
                                    {
                                        continue;
                                    }

                                    var promotionItem = new PromotionItem();
                                    //标识
                                    promotionItem.Id = IdWorkerUtils.Instance.NextId();
                                    //租户ID
                                    promotionItem.TenantId = orderItem.TenantId;
                                    //订单ID
                                    promotionItem.OrderId = orderItem.OrderId;
                                    //订单编号
                                    promotionItem.TradeNo = orderItem.TradeNo;
                                    //单品编号
                                    promotionItem.ItemId = orderItem.Id;

                                    promotionItem.PromotionType = PromotionType.卡友日;

                                    promotionItem.PlanNo = fineProm.PromotionId;
                                    promotionItem.PlanName = PromotionType.卡友日.ToString();

                                    if (cont.DiscountType == 0)//(0-按比例 1-固定值)
                                    {
                                        //优惠金额
                                        var discountAmount = OrderUtils.ToRound(orderItem.ReceivableAmount * (100 - discountValue) / 100.00M);
                                        if (discountAmount > orderItem.Amount)
                                        {
                                            discountAmount = orderItem.Amount;
                                        }
                                        promotionItem.DiscountAmount = discountAmount;
                                    }
                                    else
                                    {
                                        //固定值
                                        //(0-按菜品 1-按整单)
                                        if (discountValue <= orderItem.DiscountPrice)
                                        {
                                            //优惠金额
                                            promotionItem.DiscountAmount = OrderUtils.ToRound(discountValue * orderItem.Quantity);
                                        }
                                        else
                                        {
                                            promotionItem.DiscountAmount = orderItem.ReceivableAmount;
                                        }

                                    }
                                    PromotionUtils.Calculate(_orderObject, orderItem, promotionItem);

                                    needUpdate = true;
                                }
                            }
                        }
                    }
                    break;
                case PromotionType.会员价:
                    {
                        BusinessUtils.Instance.AddMemberPromotion(_orderObject, _orderItem);
                        needUpdate = true;
                    }
                    break;
                case PromotionType.商品优惠券:
                    {
                        BusinessUtils.Instance.AddProductCouponPromotion(_orderObject, _orderItem, fineProm);
                        needUpdate = true;
                    }
                    break;
                case PromotionType.会员等级优惠:
                    {
                        BusinessUtils.Instance.AddMemberLevelPromotion(_orderObject, _orderItem, fineProm);
                        needUpdate = true;
                    }
                    break;
                case PromotionType.商品促销:
                    {
                        //享受优惠的前提是 1、没有整单优惠  2、单品没有享受优惠
                        bool isGo = true;
                        if (isGo && _orderObject.Promotions != null && _orderObject.Promotions.Count > 0)
                        {
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //订单不存在优惠
                            //商品促销优惠
                            var promotion = new PromotionItem();
                            //标识
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            //租户ID
                            promotion.TenantId = _orderItem.TenantId;
                            //订单ID
                            promotion.OrderId = _orderItem.OrderId;
                            //订单编号
                            promotion.TradeNo = _orderItem.TradeNo;
                            //单品编号
                            promotion.ItemId = _orderItem.Id;
                            //类型
                            promotion.PromotionType = PromotionType.商品促销;
                            //方案
                            promotion.PlanNo = fineProm.PromotionId;
                            //方案名称
                            promotion.PlanName = PromotionType.商品促销.ToString();
                            //优惠金额
                            promotion.DiscountAmount = fineProm.DiscountAmount;
                            //折扣率
                            if (_orderItem.Price != 0)
                            {
                                promotion.DiscountRate = OrderUtils.ToRound((_orderItem.Amount - fineProm.DiscountAmount) / _orderItem.Amount);
                            }
                            else
                            {
                                promotion.DiscountRate = 0;
                            }

                            PromotionUtils.Calculate(_orderObject, _orderItem, promotion);

                            needUpdate = true;
                        }
                    }
                    break;
                case PromotionType.双数特价优惠:
                    {
                        //享受优惠的前提是 1、没有整单优惠  2、单品没有享受优惠
                        bool isGo = true;
                        if (isGo && _orderObject.Promotions != null && _orderObject.Promotions.Count > 0)
                        {
                            isGo = false;
                        }

                        if (isGo)
                        {
                            //订单不存在优惠
                            //商品促销优惠
                            var promotion = new PromotionItem();
                            //标识
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            //租户ID
                            promotion.TenantId = _orderItem.TenantId;
                            //订单ID
                            promotion.OrderId = _orderItem.OrderId;
                            //订单编号
                            promotion.TradeNo = _orderItem.TradeNo;
                            //单品编号
                            promotion.ItemId = _orderItem.Id;
                            //类型
                            promotion.PromotionType = PromotionType.双数特价优惠;
                            //方案
                            promotion.PlanNo = fineProm.PromotionId;
                            //方案名称
                            promotion.PlanName = PromotionType.双数特价优惠.ToString();
                            //优惠金额
                            promotion.DiscountAmount = fineProm.DiscountAmount;
                            //折扣率
                            if (_orderItem.Price != 0)
                            {
                                promotion.DiscountRate = OrderUtils.ToRound((_orderItem.Amount - fineProm.DiscountAmount) / _orderItem.Amount);
                            }
                            else
                            {
                                promotion.DiscountRate = 0;
                            }

                            PromotionUtils.Calculate(_orderObject, _orderItem, promotion);


                            needUpdate = true;
                        }
                    }
                    break;
            }
            return needUpdate;
        }

        public void ApplyOrderPromotionMeituan(OrderObject _orderObject, PromotionEntity fineProm)
        {
            switch (fineProm.Type)
            {
                case PromotionType.美团团购券:
                    {
                        var promotion = new PromotionOrder();
                        //标识
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        //租户ID
                        promotion.TenantId = _orderObject.TenantId;
                        //订单ID
                        promotion.OrderId = _orderObject.Id;
                        //订单编号
                        promotion.TradeNo = _orderObject.TradeNo;
                        promotion.PromotionType = fineProm.Type;

                        promotion.DiscountAmount = fineProm.DiscountAmount;
                        promotion.PlanNo = fineProm.PromotionId;
                        promotion.PlanName = fineProm.PromotionDesc;
                        promotion.CouponId = fineProm.CouponId;


                        var lists = _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明);

                        //已经分摊金额的合计，用于处理最后一个单品相减的问题
                        decimal sum = 0;
                        //有效商品金额
                        decimal validAmount = lists.Sum(x => x.ReceivableAmount);
                        for (int i = 0; i < lists.Count; i++)
                        {
                            var orderItem = lists[i];

                            //忽略套餐明细，套餐明细依赖套餐主分摊折扣
                            if (orderItem.RowState == OrderRowState.套餐明)
                            {
                                continue;
                            }

                            //折扣优惠，相对固定值是输入的 折扣率
                            var discount = new PromotionItem();
                            //折扣标识
                            discount.Id = IdWorkerUtils.Instance.NextId();
                            //折扣类型
                            discount.PromotionType = promotion.PromotionType;
                            //租户ID
                            discount.TenantId = orderItem.TenantId;
                            //订单ID
                            discount.OrderId = orderItem.OrderId;
                            //订单编号
                            discount.TradeNo = orderItem.TradeNo;
                            //单品编号
                            discount.ItemId = orderItem.Id;

                            //分摊数据对应整单优惠的行数据ID
                            discount.RelationId = promotion.Id;

                            discount.PlanNo = promotion.PlanNo;

                            discount.PlanName = promotion.PlanName;

                            //兑换券ID
                            discount.CouponId = promotion.CouponId;

                            //分摊的金额
                            var _amount = OrderUtils.ToRound(orderItem.ReceivableAmount / validAmount * promotion.DiscountAmount);
                            //如果是最后一条记录，分摊金额采用减法
                            if (i + 1 == _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明).Count)
                            {
                                _amount = promotion.DiscountAmount - sum;
                            }
                            else
                            {
                                sum += _amount;
                            }
                            //优惠前金额
                            discount.Amount = orderItem.ReceivableAmount;
                            //优惠金额
                            discount.DiscountAmount = _amount;
                            //优惠后金额
                            discount.ReceivableAmount = orderItem.ReceivableAmount - _amount;
                            //折扣率
                            if (orderItem.ReceivableAmount == 0)
                            {
                                discount.DiscountRate = 0;
                            }
                            else
                            {
                                discount.DiscountRate = OrderUtils.ToRound(discount.ReceivableAmount / orderItem.ReceivableAmount);
                            }

                            //优惠生效
                            discount.Enabled = true;

                            //折扣，影响折扣后的单价 = 折扣的总金额 / 购买的数量
                            orderItem.DiscountPrice = OrderUtils.ToDiscountPrice(discount.ReceivableAmount / orderItem.Quantity);
                            //添加明细优惠
                            orderItem.Promotions.Add(discount);
                            //套餐道菜分摊
                            PromotionUtils.CalculateSuitShare(_orderObject, orderItem);

                        }
                        //添加主单优惠
                        _orderObject.Promotions.Add(promotion);
                    }
                    break;
            }
        }
        /// <summary>
        /// 电子代金券单独算优惠
        /// </summary>
        /// <param name="fineProm"></param>
        public void ApplyOrderPromotionDZDJQ(OrderObject _orderObject, PromotionEntity fineProm)
        {
            switch (fineProm.Type)
            {
                case PromotionType.电子代金券:
                    {
                        var promotion = new PromotionOrder();
                        //标识
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        //租户ID
                        promotion.TenantId = _orderObject.TenantId;
                        //订单ID
                        promotion.OrderId = _orderObject.Id;
                        //订单编号
                        promotion.TradeNo = _orderObject.TradeNo;
                        promotion.PromotionType = fineProm.Type;

                        promotion.DiscountAmount = fineProm.DiscountAmount;
                        promotion.PlanNo = fineProm.PromotionId;
                        promotion.PlanName = fineProm.PromotionDesc;
                        promotion.CouponId = fineProm.CouponId;

                        //PromotionUtils.Calculate(_orderObject, promotion);
                        //已经分摊金额的合计，用于处理最后一个单品相减的问题
                        decimal sum = 0;
                        //有效商品金额
                        decimal validAmount = _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明).Sum(x => x.ReceivableAmount);
                        for (int i = 0; i < _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明).Count; i++)
                        {
                            var orderItem = _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明)[i];

                            if (fineProm.Type == PromotionType.电子代金券)
                            {
                                if (!Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_VOUCHER_ALLOWS_DISCOUNT, false))
                                    //服务端禁止单品折扣
                                    if (orderItem.DiscountFlag == 0)
                                    {
                                        orderItem.Action = "云端不允许优惠";
                                        continue;
                                    }
                            }
                            else
                            {
                                //服务端禁止单品折扣
                                if (orderItem.DiscountFlag == 0)
                                {
                                    orderItem.Action = "云端不允许优惠";
                                    continue;
                                }
                            }



                            //忽略套餐明细，套餐明细依赖套餐主分摊折扣
                            if (orderItem.RowState == OrderRowState.套餐明)
                            {
                                continue;
                            }
                            //折扣优惠，相对固定值是输入的 折扣率
                            var discount = new PromotionItem();
                            //折扣标识
                            discount.Id = IdWorkerUtils.Instance.NextId();
                            //折扣类型
                            discount.PromotionType = promotion.PromotionType;
                            //租户ID
                            discount.TenantId = orderItem.TenantId;
                            //订单ID
                            discount.OrderId = orderItem.OrderId;
                            //订单编号
                            discount.TradeNo = orderItem.TradeNo;
                            //单品编号
                            discount.ItemId = orderItem.Id;

                            //分摊数据对应整单优惠的行数据ID
                            discount.RelationId = promotion.Id;

                            discount.PlanNo = promotion.PlanNo;

                            discount.PlanName = promotion.PlanName;

                            //兑换券ID
                            discount.CouponId = promotion.CouponId;

                            //分摊的金额
                            var _amount = OrderUtils.ToRound(orderItem.ReceivableAmount / validAmount * promotion.DiscountAmount);
                            //如果是最后一条记录，分摊金额采用减法
                            if (i + 1 == _orderObject.Items.FindAll(x => x.RowState != OrderRowState.套餐明).Count)
                            {
                                _amount = promotion.DiscountAmount - sum;
                            }
                            else
                            {
                                sum += _amount;
                            }
                            //优惠前金额
                            discount.Amount = orderItem.ReceivableAmount;
                            //优惠金额
                            discount.DiscountAmount = _amount;
                            //优惠后金额
                            discount.ReceivableAmount = orderItem.ReceivableAmount - _amount;
                            //折扣率
                            if (orderItem.ReceivableAmount == 0)
                            {
                                discount.DiscountRate = 0;
                            }
                            else
                            {
                                discount.DiscountRate = OrderUtils.ToRound(discount.ReceivableAmount / orderItem.ReceivableAmount);
                            }

                            //优惠生效
                            discount.Enabled = true;

                            //折扣，影响折扣后的单价 = 折扣的总金额 / 购买的数量
                            orderItem.DiscountPrice = OrderUtils.ToDiscountPrice(discount.ReceivableAmount / orderItem.Quantity);
                            //添加明细优惠
                            orderItem.Promotions.Add(discount);
                            //套餐道菜分摊
                            PromotionUtils.CalculateSuitShare(_orderObject, orderItem);
                        }
                        //添加主单优惠
                        _orderObject.Promotions.Add(promotion);
                    }
                    break;
            }
        }
        /// <summary>
        /// 应用订单优惠
        /// </summary>
        /// <param name="fineProm"></param>
        public void ApplyOrderPromotion(OrderObject _orderObject, PromotionEntity fineProm)
        {
            switch (fineProm.Type)
            {
                case PromotionType.卡友日:
                    {
                        var pro = PromotionEngine.Instance.Promotions.Find(x => x.Type == PromotionType.卡友日.ToString());
                        if (pro != null)
                        {
                            var cont = JsonUtils.Deserialize<CardProDay>(pro.Content);
                            var discountValue = cont.DiscountValue;

                            // (0-按菜品 1-按整单)都按照整单计算比例
                            if (cont.ReferType == 1)
                            {
                                //1-按整单
                                var promotion = new PromotionOrder();
                                //标识
                                promotion.Id = IdWorkerUtils.Instance.NextId();
                                //租户ID
                                promotion.TenantId = _orderObject.TenantId;
                                //订单ID
                                promotion.OrderId = _orderObject.Id;
                                //订单编号
                                promotion.TradeNo = _orderObject.TradeNo;
                                promotion.PromotionType = PromotionType.卡友日;

                                promotion.PlanNo = fineProm.PromotionId;
                                promotion.PlanName = PromotionType.卡友日.ToString();

                                var discountAmount = 0.00M;

                                //能够参与优惠的金额
                                var validAmount = PromotionUtils.GetValidPromItemsAmount(_orderObject);

                                if (cont.DiscountType == 0)//(0-按比例 1-固定值)
                                {
                                    //优惠金额
                                    discountAmount = OrderUtils.ToRound(validAmount * (100 - discountValue) / 100.00M);
                                    if (discountAmount > validAmount)
                                    {
                                        discountAmount = validAmount;
                                    }
                                }
                                else
                                {
                                    discountAmount = discountValue;
                                }
                                promotion.DiscountAmount = discountAmount;
                                PromotionUtils.Calculate(_orderObject, promotion);
                            }
                        }
                    }
                    break;
                case PromotionType.满减促销:
                    {
                        var pro = PromotionEngine.Instance.PromotionTasks.FirstOrDefault(x => x.PromotionSn == fineProm.PromotionId);
                        if (pro != null)
                        {
                            var promotion = new PromotionOrder();
                            //标识
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            //租户ID
                            promotion.TenantId = _orderObject.TenantId;
                            //订单ID
                            promotion.OrderId = _orderObject.Id;
                            //订单编号
                            promotion.TradeNo = _orderObject.TradeNo;
                            promotion.PromotionType = PromotionType.满减促销;

                            promotion.DiscountAmount = fineProm.DiscountAmount;
                            promotion.PlanNo = fineProm.PromotionId;
                            promotion.PlanName = PromotionType.满减促销.ToString();

                            //参与计算的商品
                            var joinSpecList = PromotionEngine.Instance.PromotionTasks.FindAll(x => x.PromotionSn == fineProm.PromotionId).Select(x => x.ValueId).ToList();

                            PromotionUtils.Calculate(_orderObject, promotion, joinSpecList, null);
                        }
                    }
                    break;
                case PromotionType.实体优惠券:
                    {
                        var pro = PromotionEngine.Instance.StoreCoupons.FirstOrDefault(x => x.Id == fineProm.PromotionId);
                        if (pro != null)
                        {
                            var promotion = new PromotionOrder();
                            //标识
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            //租户ID
                            promotion.TenantId = _orderObject.TenantId;
                            //订单ID
                            promotion.OrderId = _orderObject.Id;
                            //订单编号
                            promotion.TradeNo = _orderObject.TradeNo;
                            promotion.PromotionType = PromotionType.实体优惠券;

                            //能够参与优惠的金额
                            var validAmount = PromotionUtils.GetValidPromItemsAmount(_orderObject);

                            if (fineProm.DiscountAmount <= validAmount)
                            {
                                promotion.DiscountAmount = fineProm.DiscountAmount;
                            }
                            else
                            {
                                promotion.DiscountAmount = validAmount;
                            }
                            promotion.PlanNo = fineProm.PromotionId;
                            promotion.PlanName = pro.Name;

                            //优惠券ID
                            promotion.Ext1 = fineProm.CouponId;

                            PromotionUtils.Calculate(_orderObject, promotion);
                        }
                    }
                    break;
                case PromotionType.免单:
                    {
                        var promotion = new PromotionOrder();
                        //标识
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        //租户ID
                        promotion.TenantId = _orderObject.TenantId;
                        //订单ID
                        promotion.OrderId = _orderObject.Id;
                        //订单编号
                        promotion.TradeNo = _orderObject.TradeNo;
                        promotion.PromotionType = PromotionType.免单;

                        promotion.DiscountAmount = fineProm.DiscountAmount;
                        promotion.PlanNo = fineProm.PromotionId;
                        promotion.PlanName = PromotionType.免单.ToString();

                        PromotionUtils.Calculate(_orderObject, promotion);
                    }
                    break;
                case PromotionType.电子代金券:
                case PromotionType.电子折扣券:
                    {
                        var promotion = new PromotionOrder();
                        //标识
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        //租户ID
                        promotion.TenantId = _orderObject.TenantId;
                        //订单ID
                        promotion.OrderId = _orderObject.Id;
                        //订单编号
                        promotion.TradeNo = _orderObject.TradeNo;
                        promotion.PromotionType = fineProm.Type;

                        promotion.DiscountAmount = fineProm.DiscountAmount;
                        promotion.PlanNo = fineProm.PromotionId;
                        promotion.PlanName = fineProm.PromotionDesc;
                        promotion.CouponId = fineProm.CouponId;

                        PromotionUtils.Calculate(_orderObject, promotion);
                    }
                    break;
                case PromotionType.电子兑换券:
                    {

                    }
                    break;
            }
        }

        public void OrderMd(OrderObject _orderObject, decimal discountAmount)
        {
            PromotionEntity prom = new PromotionEntity();
            prom.Type = PromotionType.免单;
            prom.DiscountAmount = discountAmount;
            prom.IsOrder = true;
            prom.PromotionDesc = PromotionType.免单.ToString();

            ApplyOrderPromotion(_orderObject, prom);
        }

        #endregion

        #region 会员卡操作

        /// <summary>
        /// 订单赠送积分，非会员卡支付时使用
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> AddCardPoint4Order(OrderObject orderObject)
        {
            try
            {
                if (orderObject.IsMember == 1)
                {
                    logger.Info("会员[{0}]充值消费积分,订单[{1}]", orderObject.Member.Id, orderObject.TradeNo);
                    var result = CreateOrderCardTrade(orderObject);
                    if (result.Item1)
                    {

                        //记积分金额
                        var pointAmount = orderObject.Pays.FindAll(x => x.PointFlag == 1).Sum(x => x.Amount);

                        var request = new CardTradePayRequest();

                        request.TradeNo = orderObject.TradeNo;

                        request.MemberId = orderObject.Member == null ? string.Empty : orderObject.Member.Id;
                        request.Mobile = orderObject.Member == null ? string.Empty : orderObject.Member.Mobile;

                        request.TradeVoucherNo = result.Item3.TradeVoucherNo;

                        request.TotalAmount = Convert.ToInt32(orderObject.Amount * 100);

                        request.RealAmount = Convert.ToInt32(orderObject.PaidAmount * 100);

                        request.PointAmount = orderObject.Member == null ? 0 : Convert.ToInt32(pointAmount * 100);

                        request.PayCardAmount = 0;//单独充值积分传0

                        request.DiscountAmount = Convert.ToInt32(orderObject.DiscountAmount * 100);

                        request.PointFlag = 2;//以卡系统计算为准
                        request.PointValue = 0;

                        request.PayInfo = new List<PayInfo>();

                        var pays = new List<Pay>();
                        foreach (var p in orderObject.Pays)
                        {
                            var pay = new Pay();
                            pay.PayTypeNo = p.No;
                            pay.PayType = p.Name;
                            pay.Money = Convert.ToInt32(p.Amount * 100);
                            pay.PointRule = string.Empty;
                            pay.Point = 0;

                            pays.Add(pay);
                        }

                        request.Pay = pays;
                        int couponTotalAmount = 0;
                        var coupons = new List<Coupon>();
                        if (orderObject.Promotions != null)
                        {
                            foreach (PromotionOrder promotionOrder in orderObject.Promotions)
                            {
                                if (PromotionType.电子代金券 == promotionOrder.PromotionType)
                                {
                                    Coupon coupon = new Coupon();
                                    coupon.CouponId = promotionOrder.CouponId;
                                    coupon.CouponType = "CASH";
                                    coupon.Title = promotionOrder.PlanName;
                                    coupon.Code = promotionOrder.PlanNo;
                                    coupon.Discount = String.Format("{0}", promotionOrder.DiscountRate);
                                    coupon.Cash = String.Format("{0}", promotionOrder.DiscountAmount);
                                    coupon.Gift = promotionOrder.PlanName;
                                    coupon.Memo = String.Format("电子代金券,优惠{0}", promotionOrder.DiscountAmount);
                                    couponTotalAmount += Convert.ToInt32(promotionOrder.DiscountAmount * 100);
                                    coupons.Add(coupon);
                                }
                                else if (PromotionType.电子折扣券 == promotionOrder.PromotionType)
                                {
                                    Coupon coupon = new Coupon();
                                    coupon.CouponId = promotionOrder.CouponId;
                                    coupon.CouponType = "DISCOUNT";
                                    coupon.Title = promotionOrder.PlanName;
                                    coupon.Code = promotionOrder.PlanNo;
                                    coupon.Discount = String.Format("{0}", promotionOrder.DiscountRate);
                                    coupon.Cash = String.Format("{0}", promotionOrder.DiscountAmount);
                                    coupon.Gift = promotionOrder.PlanName;
                                    coupon.Memo = String.Format("电子折扣券,优惠{0}", promotionOrder.DiscountAmount);
                                    couponTotalAmount += Convert.ToInt32(promotionOrder.DiscountAmount * 100);
                                    coupons.Add(coupon);
                                }
                            }
                        }
                        if (orderObject.Items != null)
                        {
                            foreach (OrderItem orderItem in orderObject.Items)
                            {
                                if (orderItem.Promotions != null)
                                {
                                    foreach (PromotionItem promotionItem in orderItem.Promotions)
                                    {
                                        if (PromotionType.电子兑换券 == promotionItem.PromotionType)
                                        {
                                            Coupon coupon = new Coupon();
                                            coupon.CouponId = promotionItem.CouponId;
                                            coupon.CouponType = "GIFT";
                                            coupon.Title = promotionItem.PlanName;
                                            coupon.Code = promotionItem.PlanNo;
                                            coupon.Discount = String.Format("{0}", promotionItem.DiscountRate);
                                            coupon.Cash = String.Format("{0}", promotionItem.DiscountAmount);
                                            coupon.Gift = promotionItem.PlanName;
                                            coupon.Memo = String.Format("电子兑换券,优惠{0}", promotionItem.DiscountAmount);
                                            couponTotalAmount += Convert.ToInt32(promotionItem.DiscountAmount * 100);
                                            coupons.Add(coupon);
                                        }

                                    }
                                }
                            }
                        }
                        request.Coupon = coupons;
                        request.CouponTotalAmount = couponTotalAmount;
                        request.ShopNo = Global.Instance.Authc.StoreNo;
                        request.WorkerNo = Global.Instance.Worker.No;
                        request.PosNo = Global.Instance.Authc.PosNo;

                        var payResult = CardUtils.CardTradePay(request);

                        if (payResult.Item1)
                        {

                            var payRes = payResult.Item3;
                            //刷卡后积分计入主单
                            orderObject.PrePoint = OrderUtils.ToRound(payRes.PrePoint / 100.00M);
                            orderObject.AddPoint = OrderUtils.ToRound(payRes.GiftPoint / 100.00M);
                            orderObject.AftPoint = OrderUtils.ToRound(payRes.AftPoint / 100.00M);

                            logger.Info("订单[{0}]充值积分[{1}]成功", orderObject.TradeNo, orderObject.AddPoint);
                            return new Tuple<bool, string>(true, "充值积分成功");
                        }
                        else
                        {
                            //会员充值积分失败
                            logger.Error(string.Format("订单[{0}]充值积分失败，原因{1}", orderObject.TradeNo, payResult.Item2));
                            return new Tuple<bool, string>(false, payResult.Item2);
                        }

                    }
                    else
                    {
                        return new Tuple<bool, string>(false, result.Item2);
                    }
                }
                else
                {
                    return new Tuple<bool, string>(true, "非会员订单，不充值积分");
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "订单充值积分发生异常");
                return new Tuple<bool, string>(false, "订单充值积分发生异常");
            }
        }

        /// <summary>
        /// 创建订单预支付订单
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string, CardTradeCreateVoucherNoResponse> CreateOrderCardTrade(OrderObject orderObject)
        {
            try
            {
                var request = new CardTradeCreateVoucherNoRequest();

                request.TradeNo = orderObject.TradeNo;
                request.BatchNo = "";
                request.SerialNo = "";
                request.SaleDate = orderObject.SaleDate;
                request.Subject = orderObject.StoreName;
                request.Body = "";
                request.TotalAmount = Convert.ToInt32(orderObject.Amount * 100);
                request.DiscountAmount = Convert.ToInt32(orderObject.DiscountAmount * 100);

                var goodsDetails = new List<GoodsDetail>();
                foreach (OrderItem orderItem in orderObject.Items)
                {
                    GoodsDetail detail = new GoodsDetail();
                    detail.GoodsId = orderItem.ProductNo;
                    detail.Name = orderItem.Name;
                    detail.Spec = orderItem.SpecName;
                    detail.Quantity = orderItem.Quantity;
                    detail.Price = orderItem.SalePrice;
                    detail.DiscountMoney = orderItem.DiscountAmount;
                    detail.Money = orderItem.ReceivableAmount;
                    detail.Point = 0.00M;
                    detail.Promotion = "";
                    goodsDetails.Add(detail);
                }
                request.GoodsDetail = goodsDetails;

                var proDetails = new List<ProDetail>();
                request.ProDetail = proDetails;

                request.ShopNo = Global.Instance.Authc.StoreNo;
                request.WorkerNo = Global.Instance.Worker.No;
                request.PosNo = Global.Instance.Authc.PosNo;

                var data = CardUtils.CardTradeCreateVoucherNo(request);

                if (data.Item1)
                {
                    logger.Info("订单[{0}]创建卡预支付成功，预支付号[{1}]", orderObject.TradeNo, data.Item3.TradeVoucherNo);
                    return new Tuple<bool, string, CardTradeCreateVoucherNoResponse>(true, null, data.Item3);
                    //充值积分
                }
                else
                {
                    logger.Error(string.Format("订单[{0}]创建卡预支付，原因[{1}]", orderObject.TradeNo, data.Item2));
                    return new Tuple<bool, string, CardTradeCreateVoucherNoResponse>(false, data.Item2, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "创建订单会员卡预支付订单异常");
                return new Tuple<bool, string, CardTradeCreateVoucherNoResponse>(false, "创建订单会员卡预支付订单异常", null);
            }
        }

        /// <summary>
        /// 统一收单-卡支付明细
        /// </summary>
        /// <param name="tradeVoucherNo"></param>
        /// <param name="currentCard"></param>
        /// <returns></returns>
        public Tuple<bool, string, CardTradeCreateCardResponse> CreateCardTrade(string tradeNo, decimal payAmount, string tradeVoucherNo, MemberCard currentCard)
        {
            Tuple<bool, string, CardTradeCreateCardResponse> result = null;

            try
            {
                var request = new CardTradeCreateCardRequest();
                request.TradeVoucherNo = tradeVoucherNo;
                request.TradeNo = tradeNo;
                request.CardNo = currentCard.CardNo;

                request.CardTypeNo = currentCard.CardTypeNo;
                request.CardLevelNo = currentCard.CardLevelNo;
                request.Amount = Convert.ToInt32(payAmount * 100);

                request.ShopNo = Global.Instance.Authc.StoreNo;
                request.WorkerNo = Global.Instance.Worker.No;
                request.PosNo = Global.Instance.Authc.PosNo;

                //会员卡统一下单
                var unifiedOrder = CardUtils.CardTradeCreateCard(request);
                if (!unifiedOrder.Item1)
                {
                    result = new Tuple<bool, string, CardTradeCreateCardResponse>(false, unifiedOrder.Item2, null);
                }
                else
                {
                    result = new Tuple<bool, string, CardTradeCreateCardResponse>(true, unifiedOrder.Item2, unifiedOrder.Item3);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, string.Format("订单<{0}>卡<{1}>支付<{2}>统一下单(卡支付明细)异常", tradeNo, currentCard.CardNo, payAmount));
                result = new Tuple<bool, string, CardTradeCreateCardResponse>(false, "统一下单(卡支付明细)异常", null);
            }
            return result;
        }

        /// <summary>
        /// 订单核销实体代金券
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> ConsumeStoreCoupon(OrderObject orderObject)
        {
            bool status = true;
            string message = string.Empty;
            try
            {
                if (orderObject.Promotions != null)
                {
                    var couponPromList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.实体优惠券 && !string.IsNullOrEmpty(x.Ext1)).ToList();
                    if (couponPromList.Count > 0)
                    {
                        //逐个核销
                        foreach (var coupon in couponPromList)
                        {
                            logger.Info("订单<{0}>发起实体优惠券核销<{1}>,优惠金额<{2}>", orderObject.TradeNo, coupon.Ext1, coupon.DiscountAmount);
                            //核销实体券
                            StoreCouponCheckRequest request = new StoreCouponCheckRequest();
                            request.CouponCode = coupon.Ext1;
                            request.BusNo = orderObject.TradeNo;
                            var result = StoreBusinessUtils.StoreCouponCheck(request);
                            logger.Info("订单<{0}>实体优惠券<{1}>核销结果：{2}", orderObject.TradeNo, coupon.PlanNo, result.Item2);
                            if (result.Item1)
                            {
                                //成功
                                logger.Info("订单<{0}>实体优惠券<{1}>核销成功", orderObject.TradeNo, coupon.PlanNo);
                            }
                            else
                            {
                                //失败
                                status = false;
                                message = result.Item2;
                                break;
                            }
                        }
                    }
                }
                //兑换券单独核销
            }
            catch (Exception ex)
            {
                logger.Error(ex, "实体优惠券核销发生异常");
                status = false;
                message = "实体优惠券核销发生异常";
            }
            return new Tuple<bool, string>(status, message);
        }

        public Tuple<bool, string> MeituanCouponConsume(OrderObject orderObject)
        {
            bool status = true;
            string message = string.Empty;
            try
            {
                if (orderObject.Pays != null)
                {
                    var couponList = orderObject.Pays.FindAll(x => "12".Equals(x.No)).ToList();
                    if (couponList.Count > 0)
                    {
                        //逐个核销
                        foreach (var coupon in couponList)
                        {
                            logger.Info("订单<{0}>发起核销美团券<{1}>", orderObject.TradeNo, coupon.TradeVoucherNo);


                            var request = new TuangouOrderConsumeRequest();
                            request.VendorShopId = Global.Instance.Authc.StoreNo;
                            request.VendorOrderId = orderObject.TradeNo;
                            request.TotalAmount = orderObject.Amount;
                            request.CouponCode = coupon.TradeVoucherNo;//美团券码

                            var skus = new List<OrderSku>();

                            foreach (var item in orderObject.Items)
                            {
                                var sku = new OrderSku();
                                sku.VendorSkuId = item.SpecId;
                                sku.VendorSkuName = item.DisplayName;
                                sku.Unit = item.ProductUnitName;
                                sku.UnitPrice = item.Price;
                                sku.Count = 1;

                                skus.Add(sku);
                            }

                            request.OrderSkus = skus;
                            request.EId = Global.Instance.Worker.No;
                            request.EName = Global.Instance.Worker.Name;

                            var result = MeituanCouponUtils.Instance.OrderConsume(request);
                            logger.Info("订单<{0}>美团券<{1}>核销结果：{2}", orderObject.TradeNo, coupon.TradeVoucherNo, result.Item2);
                            if (result.Item1)
                            {
                                //成功
                                logger.Info("订单<{0}>电子券<{1}>核销成功", orderObject.TradeNo, coupon.TradeVoucherNo);
                            }
                            else
                            {
                                //失败
                                status = false;
                                message = result.Item2;
                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "美团券核销发生异常");
                status = false;
                message = "美团券核核销发生错误，本次核销无效";
            }
            return new Tuple<bool, string>(status, message);
        }

        /// <summary>
        /// 订单电子券核销
        /// </summary>
        /// <param name="orderObject"></param>
        /// <returns></returns>
        public Tuple<bool, string> ConsumeElecCoupon(OrderObject orderObject)
        {
            bool status = true;
            string message = string.Empty;
            try
            {
                if (orderObject.Promotions != null)
                {
                    var couponPromList = orderObject.Promotions.FindAll(x => x.PromotionType == PromotionType.电子代金券 || x.PromotionType == PromotionType.电子折扣券).ToList();
                    if (couponPromList.Count > 0)
                    {
                        string mobileNo = null;
                        string cardNo = null;
                        if (orderObject.Member != null)
                        {
                            mobileNo = orderObject.Member.Mobile;
                            if (orderObject.Member.CurrentCard != null)
                            {
                                cardNo = orderObject.Member.CurrentCard.CardNo;
                            }
                        }
                        //逐个核销
                        foreach (var coupon in couponPromList)
                        {
                            logger.Info("订单<{0}>发起核销电子券<{1}>,优惠金额<{2}>", orderObject.TradeNo, coupon.PlanNo, coupon.DiscountAmount);
                            var result = CardUtils.ConsumeElecCoupon(orderObject.TradeNo, coupon.PlanNo, mobileNo, cardNo, "saoma", (int)(orderObject.Amount * 100), (int)(coupon.DiscountAmount * 100));
                            logger.Info("订单<{0}>电子券<{1}>核销结果：{2}", orderObject.TradeNo, coupon.PlanNo, result.Item2);
                            if (result.Item1)
                            {
                                //成功
                                logger.Info("订单<{0}>电子券<{1}>核销成功", orderObject.TradeNo, coupon.PlanNo);
                            }
                            else
                            {
                                //失败
                                status = false;
                                message = result.Item2;
                                break;
                            }
                        }
                    }
                }
                //商品兑换券核销
                if (orderObject.Items != null)
                {
                    foreach (OrderItem item in orderObject.Items)
                    {
                        if (item.Promotions != null)
                        {
                            var couponPromList = item.Promotions.FindAll(x => x.PromotionType == PromotionType.电子兑换券 || x.PromotionType == PromotionType.电子商品券).ToList();
                            if (couponPromList.Count > 0)
                            {
                                string mobileNo = null;
                                string cardNo = null;
                                if (orderObject.Member != null)
                                {
                                    mobileNo = orderObject.Member.Mobile;
                                    if (orderObject.Member.CurrentCard != null)
                                    {
                                        cardNo = orderObject.Member.CurrentCard.CardNo;
                                    }
                                }
                                //逐个核销
                                foreach (var coupon in couponPromList)
                                {
                                    logger.Info("订单<{0}>发起核销电子券<{1}>,优惠金额<{2}>", orderObject.TradeNo, coupon.PlanNo, coupon.DiscountAmount);
                                    var result = CardUtils.ConsumeElecCoupon(orderObject.TradeNo, coupon.PlanNo, mobileNo, cardNo, "saoma", (int)(orderObject.Amount * 100), (int)(coupon.DiscountAmount * 100));
                                    logger.Info("订单<{0}>电子券<{1}>核销结果：{2}", orderObject.TradeNo, coupon.PlanNo, result.Item2);
                                    if (result.Item1)
                                    {
                                        //成功
                                        logger.Info("订单<{0}>电子券<{1}>核销成功", orderObject.TradeNo, coupon.PlanNo);
                                    }
                                    else
                                    {
                                        //失败
                                        status = false;
                                        message = result.Item2;
                                        break;
                                    }
                                }
                            }
                        }
                    }

                }
                //兑换券单独核销
            }
            catch (Exception ex)
            {
                logger.Error(ex, "电子券核销发生异常");
                status = false;
                message = "电子券核销发生异常";
            }
            return new Tuple<bool, string>(status, message);
        }

        #endregion


    }
}