using POSV.Bean;
using POSV.Bill;
using POSV.Card;
using POSV.Cef.FastTemplate.PayMent.Base;
using POSV.Entity;
using POSV.MessageEvent;
using POSV.ShoppingCart;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace POSV.Cef.FastTemplate.PayMent
{
    public class Member_Pay : PayBase
    {

        //==================  共有参数  =================
        /// <summary>
        /// 会员卡参数配置规则
        /// </summary>
        private MemberCardItem _currentCardItem = JsonUtils.Deserialize<MemberCardItem>(Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_MEMBER_CARD));
        /// <summary>
        /// 会员信息查询应答结果
        /// </summary>
        private MemberInfoQueryResponse _currentMemberInfo = null;
        /// <summary>
        /// 读卡方式
        /// </summary>
        private MemberCardOperator _currentOperator = MemberCardOperator.会员刷卡;
        /// <summary>
        /// 当前会员选择的会员卡
        /// </summary>
        private MemberCard _currentCard = null;
        /// <summary>
        /// 会员卡支付前,请求的交易参考号
        /// </summary>
        private CardTradeCreateVoucherNoResponse _newVoucherNo = null;

        /// <summary>
        /// 扣款结果集,模拟异步查询结果，用户发起支付将结果保存本次内存中。
        /// </summary>
        private CardTradeCreateCardResponse createCardResponse = null;

        /// <summary>
        /// 扣款成功的加密字符
        /// </summary>
        private string passwd = "";

        /// <summary>
        /// 会员信息查询请求
        /// </summary>
        private MemberInfoQueryRequest m_queryRequest = new MemberInfoQueryRequest();

        /// <summary>
        /// 统一下单(卡支付明细)
        /// </summary>
        private CardTradeCreateCardRequest cardTradeCreate = null;


        public override PayItem PayStart()
        {
            var _data = this.PayResult();

            if (_data.Item1)
            {
                return this.QueryPay();
            }
            else
            {
                return null;
            }
        }
        public override void AsyncPayStart()
        {
            Task.Factory.StartNew(() =>
            {
                if (this.AsyncPayResult != null)
                {
                    this.m_QueryQuantity = 0;

                    var _data = this.PayResult();

                    var _Query = this.QueryPay();


                    this.AddMCardPayType(cardTradeCreate, createCardResponse,false, passwd,_Query);

                    this.AsyncPayResult(this.m_OrderObject, _Query, this.m_PayCode, this.m_Message, this.m_QueryQuantity);
                }
            });
        }



        protected override Tuple<bool, string, decimal> PayResult()
        {
            var resp = CardUtils.MemberInfoQuery(m_queryRequest);

            //查询成功
            if (resp.Item1)
            {
                //查询返回结果
                this._currentMemberInfo = resp.Item3;
                //读卡方式
                this._currentMemberInfo.GetWay = MemberCardNoType.电子卡号;

                if (this._currentMemberInfo.CardList.Count == 0)
                {
                    this.m_Message = "没有可用的会员卡...";
                    return null;
                }


                //当前会员
                if (this.m_OrderObject.Member == null && this._currentCardItem.Function.Contains(MemberCardFunctions.会员储值及消费))
                {
                    this.m_OrderObject.Member = this._currentMemberInfo;

                    //外部未刷卡，新会员，执行订单会员价
                    foreach (var item in this.m_OrderObject.Items)
                    {
                        //套餐，自动找到套餐主菜进行优惠计算
                        if (item != null && item.RowState == OrderRowState.套餐明)
                        {
                            //套餐明细，找到套餐主菜进行优惠计算
                            var mainItem = this.m_OrderObject.Items.Find(x => x.Group == item.Group && x.RowState == OrderRowState.套餐主);
                            if (mainItem != null)
                            {

                                if (item.Promotions != null && item.Promotions.Count > 0)
                                {
                                    //有优惠，不计算单品优惠
                                    //return;
                                }
                                else
                                {
                                    var promResult = PromotionEngine.Instance.CalItemPromotion(this.m_OrderObject, item);
                                    if (promResult.Count > 0)
                                    {
                                        if (promResult.Exists(x => x.Type == PromotionType.双数特价优惠 || x.Type == PromotionType.双数特价赠送))
                                        {
                                            //ApplyDoublePromMain(promResult, item);
                                        }
                                        else
                                        {
                                            var fineProm = promResult.OrderByDescending(x => x.DiscountAmount).ToList()[0];
                                            var needUpdate = BusinessUtils.Instance.ApplyItemFinePromotion(this.m_OrderObject, item, fineProm);
                                        }
                                    }
                                }

                            }
                        }
                        else
                        {
                            if (item != null && item.Promotions != null && item.Promotions.Count > 0)
                            {
                                //有优惠，不计算单品优惠
                                //return;
                            }
                            else
                            {
                                var promResult = PromotionEngine.Instance.CalItemPromotion(this.m_OrderObject, item);
                                if (promResult.Count > 0)
                                {
                                    if (promResult.Exists(x => x.Type == PromotionType.双数特价优惠 || x.Type == PromotionType.双数特价赠送))
                                    {
                                        //ApplyDoublePromMain(promResult, item);
                                    }
                                    else
                                    {
                                        var fineProm = promResult.OrderByDescending(x => x.DiscountAmount).ToList()[0];
                                        var needUpdate = BusinessUtils.Instance.ApplyItemFinePromotion(this.m_OrderObject, item, fineProm);
                                    }
                                }
                                //套餐道菜分摊
                                PromotionUtils.CalculateSuitShare(this.m_OrderObject, item);
                            }
                        }
                    }
                }

                this._currentOperator = MemberCardOperator.会员消费;

                //只有一张会员卡，自动选择作为当前可用会员卡
                this._currentCard = this._currentMemberInfo.CardList[0];

                //当前选中的会员卡
                if (this.m_OrderObject.Member != null && this.m_OrderObject.Member.Id.Equals(this._currentMemberInfo.Id))
                {
                    this.m_OrderObject.Member.CurrentCard = this._currentCard;
                }

                //储值卡未0禁止使用 
                var skipNoMoney = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_CARDPAYSKIPNOMONEY, "0");
                if (!BusinessUtils.Instance.HavMemberPromotionCoup(this.m_OrderObject) && this._currentCard != null && this._currentCard.AvailableAmount <= 0 && "1".Equals(skipNoMoney))
                {
                    this._currentOperator = MemberCardOperator.会员刷卡;
                    this.m_OrderObject.Member = null;
                    this._currentCard = null;
                    BusinessUtils.Instance.RemoveMemberPromotion(this.m_OrderObject);

                    this.m_Message = "余额为0不允许消费，请充值或选择其他付款方式!";
                    return new Tuple<bool, string, decimal>(false, "余额为0不允许消费，请充值或选择其他付款方式!", 0.00M);
                }


            }
            else
            {
                this.m_Message = resp.Item2;
                return new Tuple<bool, string, decimal>(false, resp.Item2, 0.00M);
            }

            var cardNo = string.IsNullOrEmpty(this._currentCard.FaceNo) ? this._currentCard.CardNo : this._currentCard.CardNo;


            //不抹零
            this.m_OrderObject.MalingAmount = 0;
            //不找零
            this.m_OrderObject.ChangeAmount = 0;

            //未收金额
            var unpaidAmount = this.m_OrderObject.PaidAmount - this.m_OrderObject.ReceivedAmount;

            //如果会员余额小于未付金额,将应收金额赋值为会员余额
            if (this._currentCard.AvailableAmount < unpaidAmount)
            {
                this.m_Message = "会员余额不足";
                return new Tuple<bool, string, decimal>(false, "会员余额不足", 0.00M); ;
            }
            else
            {
                //实收金额，操作员录入消费卡金
                decimal inputAmount = this.m_OrderObject.PaidAmount - this.m_OrderObject.ReceivedAmount;


                var PaymentVerify = VerifyInputValue();


                //是否启用免密支付,前台收银参数中关闭免密支付
                bool notAllowNoPwd = this._currentCardItem.PaymentType == 0;

                //1)设置开启免密支付；2)开启免密支付，但支付金额大于免密支付额度；3）收银参数关闭免密支付
                if (notAllowNoPwd || this._currentCard.IsNoPwd == 0 || (this._currentCard.IsNoPwd == 1 && this._currentCard.NpAmount < inputAmount) || this._currentMemberInfo.GetWay == MemberCardNoType.手机号)
                {
                    this._currentOperator = MemberCardOperator.支付密码;
                    return new Tuple<bool, string, decimal>(false, "用户设置了支付密码", 0.00M);
                }
                else
                {

                    var request = new CardTradeCreateCardRequest();
                    request.TradeVoucherNo = this._newVoucherNo.TradeVoucherNo;
                    request.TradeNo = this.m_OrderObject.TradeNo;
                    request.CardNo = this._currentCard.CardNo;

                    request.CardTypeNo = this._currentCard.CardTypeNo;
                    request.CardLevelNo = this._currentCard.CardLevelNo;
                    request.Amount = Convert.ToInt32(inputAmount * 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)
                    {
                        this.m_Message = unifiedOrder.Item2;
                        return new Tuple<bool, string, decimal>(false, unifiedOrder.Item2, 0.00M);
                    }

                    //构建会员卡支付列表，默认没有支付密码，按免密支付处理，免密支付采用扣款金额RSA加密
                    string passwd = RSAFromPkcs8.encryptData(request.Amount.ToString(), "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCh5zYnahq/k+1NpEF/fs3q31W+PPnb593gs6RP07bFK3Oq84VH45POVT/UkJJZG623sGLLs/TuIoAx6wQqIQRZMtdZEwQA2fcXu9zEHN/sqa8oBeEfFzGdBE21KX8n0KCmP6GfyPUOCzte6ADl/zAfz24Tf1Q/5iB/Xc++BEVglQIDAQAB", "UTF-8");


                    this.cardTradeCreate = request;
                    this.createCardResponse = unifiedOrder.Item3;
                    this.passwd = passwd;
                    return new Tuple<bool, string, decimal>(true, "", unpaidAmount);
                }
            }
        }


        public override PayItem QueryPay()
        {
            VerifyPay(this.m_PayCode, null);

            var _data = PayResult();

            if (_data.Item1)
            {
                return ToPayObject(null);
            }

            return null;
        }




        public override bool VerifyPay(string payCode, PayMode payMode)
        {
            m_queryRequest.Keyword = this.m_PayCode;
            m_queryRequest.Property = "scanCode";
            m_queryRequest.ShopNo = Global.Instance.Authc.StoreNo;
            m_queryRequest.WorkerNo = Global.Instance.Worker.No;
            m_queryRequest.PosNo = Global.Instance.Authc.PosNo;
            return true;
        }


        protected override PayItem ToPayObject(object queryParam)
        {
            //构建支付方式
            PayItem item = OrderUtils.ToPayItem(m_CurrentPayMode);

            //租户ID
            item.TenantId = Global.Instance.Authc.TenantId;

            //订单号
            item.OrderId = this.m_OrderObject.Id;
            item.TradeNo = this.m_OrderObject.TradeNo;

            //支付编号
            item.PayNo = OrderUtils.Instance.GeneratePayNo();

            item.Id = IdWorkerUtils.Instance.NextId();
            item.Name = this.m_CurrentPayMode.Name;
            item.No = m_CurrentPayMode.No;
            item.PointFlag = m_CurrentPayMode.PointFlag;

            //实收金额
            item.PaidAmount = (decimal)( this.cardTradeCreate.Amount) /100;
            //找零金额
            item.ChangeAmount = Convert.ToDecimal(0.00);
            //已收金额，真正意义上实际收款金额
            item.Amount = (decimal)(this.cardTradeCreate.Amount) / 100;

            item.CardNo = cardTradeCreate.CardNo;

            //加入卡面号，手机号信息
            if (this._currentCard != null)
            {
                item.CardFaceNo = this._currentCard.FaceNo;
            }
            if (this.m_OrderObject.Member != null)
            {
                item.MemberMobileNo = this.m_OrderObject.Member.Mobile;
            }
            //用户确认输入密码
            item.UseConfirmed = false;

            //会员卡密码加密
            item.Passwd = passwd;

            //预支付编码
            item.PrePayNo = createCardResponse.PrePayment;
            //交易参考号
            item.TradeVoucherNo = this._newVoucherNo.TradeVoucherNo;

            item.Memo = "会员卡支付";
            item.Subscribe = string.Empty;

            //会员卡支付状态,NOT_PAID未扣款
            item.Status = (int)OrderPaymentStatus.未付款;
            item.StatusDesc = "预下单成功,未扣款";

            if (item.Amount == 0)
            {
                this.m_Message = "支付金额为0";
                return null;
            }
            return item;
        }



        private void AddMCardPayType(CardTradeCreateCardRequest request1, CardTradeCreateCardResponse response, bool useConfirmed, string passwd, PayItem payItem)
        {
            if (request1 == null || response == null || this._newVoucherNo == null) return;


            //构建会员卡支付方式
            var payMode = this.m_CurrentPayMode;
            //构建支付方式
            PayItem item = OrderUtils.ToPayItem(payMode);

            //租户ID
            item.TenantId = Global.Instance.Authc.TenantId;

            //订单号
            item.OrderId = this.m_OrderObject.Id;
            item.TradeNo = this.m_OrderObject.TradeNo;

            //支付编号
            item.PayNo = OrderUtils.Instance.GeneratePayNo();

            item.Id = IdWorkerUtils.Instance.NextId();
            item.Name = payMode.Name;
            item.No = payMode.No;
            item.PointFlag = payMode.PointFlag;

            //实收金额
            item.PaidAmount = payItem.Amount;
            //找零金额
            item.ChangeAmount = Convert.ToDecimal(0.00);
            //已收金额，真正意义上实际收款金额
            item.Amount = payItem.Amount;

            item.CardNo = request1.CardNo;

            //加入卡面号，手机号信息
            if (this._currentCard != null)
            {
                item.CardFaceNo = this._currentCard.FaceNo;
            }
            if (this.m_OrderObject.Member != null)
            {
                item.MemberMobileNo = this.m_OrderObject.Member.Mobile;
            }
            //用户确认输入密码
            item.UseConfirmed = useConfirmed;

            //会员卡密码加密
            item.Passwd = passwd;

            //预支付编码
            item.PrePayNo = response.PrePayment;
            //交易参考号
            item.TradeVoucherNo = this._newVoucherNo.TradeVoucherNo;

            item.Memo = "会员卡支付";
            item.Subscribe = string.Empty;

            //会员卡支付状态,NOT_PAID未扣款
            item.Status = (int)OrderPaymentStatus.未付款;
            item.StatusDesc = "预下单成功,未扣款";

            if (item.Amount == 0)
            {
                return;
            }
            //将会员卡压入支付清单
            this.m_OrderObject.Pays.Add(item);

            //刷新界面数据
            //this.billSummary1.Refresh(this.m_OrderObject);
            ////刷新支付列表
            //this.billGrid1.RefreshGrid(this.m_OrderObject.Pays);

            //未收金额
            var unpaidAmount = this.m_OrderObject.PaidAmount - this.m_OrderObject.ReceivedAmount;
            
            //通知结账
            //默认支付成功
            bool isPaySuccess = true;

            //查找会员卡支付列表，如果有会员卡先扣会员卡钱
            var cards = this.m_OrderObject.Pays.FindAll(x => x.No.Equals("02"));

            //包含会员卡支付，构建会员卡扣款列表
            if (cards.Count > 0)
            {
                //交易参考号
                string tradeVoucherNo = string.Empty;

                //扣款卡列表
                var payCards = new List<PayInfo>();
                foreach (var card in cards)
                {
                    PayInfo c = new PayInfo();
                    c.PrePayment = card.PrePayNo;
                    c.CardNo = card.CardNo;
                    c.Amount = Convert.ToInt32(card.Amount * 100);
                    c.IsNoPwd = card.UseConfirmed ? 0 : 1;
                    c.Passwd = card.Passwd;

                    payCards.Add(c);

                    tradeVoucherNo = card.TradeVoucherNo;
                }

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


                var request = new CardTradePayRequest();

                request.TradeNo = this.m_OrderObject.TradeNo;

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

                request.TradeVoucherNo = tradeVoucherNo;

                request.TotalAmount = Convert.ToInt32(this.m_OrderObject.Amount * 100);
                //实收金额
                request.RealAmount = Convert.ToInt32(this.m_OrderObject.PaidAmount * 100);

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

                request.PayCardAmount = payCards.Sum(x => x.Amount);

                request.DiscountAmount = Convert.ToInt32(this.m_OrderObject.DiscountAmount * 100);

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

                request.PayInfo = payCards;

                var pays = new List<Pay>();
                foreach (var p in this.m_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 (this.m_OrderObject.Promotions != null)
                {
                    foreach (PromotionOrder promotionOrder in this.m_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 (this.m_OrderObject.Items != null)
                {
                    foreach (OrderItem orderItem in this.m_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)
                {

                    //会员卡扣款清单，用于打印
                    this.m_OrderObject.CardPayResult = payResult.Item3;

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

                    //调整每张卡的扣款状态
                    foreach (var card in cards)
                    {
                        var payCard = payRes.CardList.Find(x => x.CardNo == card.CardNo);
                        if (payCard == null)
                        {
                            logger.Error(string.Format("会员卡[{0}]支付成功后返回结果未包含该卡支付信息", card.CardNo));
                        }
                        else
                        {
                            card.CardBeforeBalance = OrderUtils.ToRound(payCard.PreAmount / 100.00M);
                            card.CardAftAmount = OrderUtils.ToRound(payCard.AftAmount / 100.00M);
                        }
                        card.Status = (int)OrderPaymentStatus.已付款;
                        card.StatusDesc = payResult.Item2;

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

                        this.m_Message = payResult.Item2;
                    }

                    //会员卡扣款成功
                    isPaySuccess = true;
                }
                else
                {
                    //会员卡扣款失败
                    isPaySuccess = false;

                    this.m_Message = payResult.Item2;
                }

            }
            else
            {
                //不包含会员卡，进行判断是否使用会员，会员充值积分
                if (this.m_OrderObject.IsMember == 1)
                {

                    var result = BusinessUtils.Instance.AddCardPoint4Order(this.m_OrderObject);
                    if (result.Item1)
                    {
                        isPaySuccess = true;
                    }
                    else
                    {
                        MsgEvent.Send(Constant.PAY_MESSAGE_EVENT_NOTIFY, new Tuple<bool, string>(true, result.Item2));
                        isPaySuccess = false;
                    }
                }
            }

            //支付成功
            if (isPaySuccess)
            {

                //整单状态
                this.m_OrderObject.OrderStatus = OrderStatus.已完成;
                //整单支付状态
                this.m_OrderObject.PaymentStatus = OrderPaymentStatus.已付款;
                //通知主界面结账成功
                MsgEvent.Send(Constant.ORDER_PAYMENT_NOTIFY, this.m_OrderObject);
            }
        }
        private bool VerifyInputValue()
        {
           
            if (this._currentMemberInfo == null)
            {

                this.m_Message = "获取交易参考号失败";
                return false;

            }

            this.NewVoucherNo(false);

            //输入是否满足结账条件:消费明细中实收金额的合计 = 主单中的实收金额
            var isVerify = this.m_OrderObject.Pays.Sum(x => x.PaidAmount) >= this.m_OrderObject.PaidAmount;

            //当前选择的会员卡
            var cardNo = this._currentCard.CardNo;

            //实收金额，操作员录入消费卡金
            decimal inputAmount = this.m_OrderObject.PaidAmount - this.m_OrderObject.ReceivedAmount;
            if (inputAmount < 0)
            {
                this.m_Message = "付款金额为负数";
                return false;
            }

            if (inputAmount > this.m_OrderObject.ReceivableAmount)
            {
                this.m_Message = "不允许超出应收金额";

                return false;
            }

            //扣除已经在支付清单的余额
            decimal freeze = this.m_OrderObject.Pays.Where(x => x.CardNo == cardNo).Sum(x => x.Amount);
            //当前卡可用余额
            decimal balance = this._currentCard.AvailableAmount - freeze;
            //操作员录入消费金额大于卡余额
            if (inputAmount > balance)
            {
                this.m_Message = "卡余额不足,请重新输入";
                return false;
            }
            return true;
        }

        /// <summary>
        /// 统一收单-订单创建(获取交易参考号)
        /// </summary>
        /// <param name="refresh"></param>
        private void NewVoucherNo(bool refresh)
        {
            var data = BusinessUtils.Instance.CreateOrderCardTrade(this.m_OrderObject);

            if (data.Item1)
            {
                this._newVoucherNo = data.Item3;
            }
            else
            {
                this.m_Message = data.Item2;
                this._newVoucherNo = null;
            }
        }

    }
}