MTP2.0_CSharp/Muchinfo.MTPClient/Fx4.0/Main/05.Services/Muchinfo.TASClient.Data/Model/Account/FundsAccount.cs

using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Helper;
using Muchinfo.MTPClient.Resources;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Media;

namespace Muchinfo.MTPClient.Data.Model.Account
{
    using GalaSoft.MvvmLight;

    /// <summary>
    /// 资金账号类
    /// </summary>
    public class FundsAccount : ObservableObject
    {
        #region 字段备注
        //AccountId	账户id
        //TradeStatus 交易状态
        //Currency 币种
        //IsMain 是否母账户
        //ParentAccountID 所属母账户
        //TAAccountType 内、外部
        //RelationMainAccountID 关联账户
        //Balance	期初余额
        //CurrentBalance	期末余额
        //UsedMargin	占用保证金
        //FreezeMargin	冻结保证金
        //OtherFreezeMargin 其他冻结保证金
        //FreezeCharge 手续费冻结
        //MortgageCredit 授信金额
        //OtherCredit 其他授信金额
        //OutAmountFreeze 出金冻结
        //OutAmount	今日出金
        //InAmount	今日入金
        //PayCharge 今日手续费支出
        //ClosePL	今日平仓盈亏
        //CreditIncrease 今日授信增加
        //CreditDecrease 今日授信减少
        //OtherCreditIncrease 今日其他授信增加
        //OtherCreditDecrease 今日其他授信减少
        //TransferAmount 今日划转金额
        //OtherPay 其他支出
        //OtherIncome 其他收入
        //OutThreshold	出金阀值 
        #endregion
        public FundsAccount()
        {

        }

         //市值=最新价*数量*合约单位
        //净值=期末余额+市值+浮动盈亏-授信金额-其他授信金额；
       //可用=净值-市值-占用-冻结-其他冻结-手续费冻结-出金冻结；
      //风险率=【占用/（净值-市值）】或【（净值-市值）/占用】；
     //冻结=做市冻结+竞价冻结+混合冻结+发售冻结+交割冻结+挂牌冻结+出金冻结

        private const int c_figures = 2;



        #region 业务服务属性

        ///
        /// <summary>
        /// 可用保证金
        /// </summary>
        public decimal AvailMargin
        {
            get
            {
                //账户总浮动盈亏为负： =期末余额+总浮动盈亏-占用-冻结-其它冻结-手续费冻结-出金冻结
                //账户总浮动盈亏为正 且 113 = 0 =期末余额-占用-冻结-其它冻结-手续费冻结-出金冻结
                //账户总浮动盈亏为正 且 113 = 1  =期末余额+总浮动盈亏-占用-冻结-其它冻结-手续费冻结-出金冻结
                //*系统参数”113“（当日浮动盈利是否可用） 0:不可用 1:可用
                var pl = FloatPL;
                if (pl > 0 && !FloatAvaliabelFlag) pl = 0;
                var avail = CurrentBalance + pl - (UsedMargin + FreezeMargin + OtherFreezeMargin + FreezeCharge + OutAmountFreeze);
                return Math.Round(avail, c_figures, MidpointRounding.AwayFromZero);
            }
        }

        public string AvailMarginDisplay
        {
            get
            {
                var value = AvailMargin;
                return value.ToString("N" + c_figures);
                //if (value > 0) return value.ToString("N" + c_figures);
                //return "0.00";
            }
        }



        /// <summary>
        /// 期初余额
        /// </summary>      
        private decimal _balance;

        /// <summary>
        /// 期初余额
        /// </summary>
        [PropertyDisc("balance")]
        public decimal Balance
        {
            get
            {
                return _balance;
            }
            set
            {
                Set(() => Balance, ref _balance, value);
                RaisePropertyChanged(() => CurrentNetWorth);
                RaisePropertyChanged(() => CurrentNetWorthDisplay);
                RaisePropertyChanged(() => AvailMargin);
                RaisePropertyChanged(() => AvailMarginDisplay);
            }
        }


        /// <summary>
        /// 期初余额
        /// </summary>
  
        public string BalanceDisplay
        {
            get
            {
                return Balance.ToString("N" + c_figures);
            }
            
        }

        public string CurrentBalanceDisplay
        {
            get
            {
                return CurrentBalance.ToString("N" + c_figures);
            }

        }

        /// <summary>
        /// 平仓盈亏
        /// </summary>      
        private decimal _closePL;

        /// <summary>
        /// 平仓盈亏
        /// </summary>
        [PropertyDisc("ClosePL")]
        public decimal ClosePL
        {
            get
            {
                return _closePL;
            }
            set
            {
                Set(() => ClosePL, ref _closePL, value);
                RaisePropertyChanged(() => ClosePLDisplay);
                RaisePropertyChanged(() => ClosePLBrush);
            }
        }

        /// <summary>
        /// 账户币种
        /// </summary>      
        private string _currency;

        /// <summary>
        /// 账户币种
        /// </summary>
        public string Currency
        {
            get
            {
                if (string.IsNullOrEmpty(_currency))
                {
                    return "RMB";
                }
                return _currency;
            }
            set { Set(() => Currency, ref _currency, value); }
        }

        /// <summary>
        /// 期末余额
        /// </summary>      
        private decimal _currentBalance;

        /// <summary>
        /// 期末余额
        /// </summary>
        [PropertyDisc("currentBalance")]
        public decimal CurrentBalance
        {
            get
            {
                return _currentBalance;
            }
            set
            {
                Set(() => CurrentBalance, ref _currentBalance, value);
                RaisePropertyChanged(() => CurrentNetWorth);
                RaisePropertyChanged(() => CurrentNetWorthDisplay);
                RaisePropertyChanged(() => AvailMargin);
                RaisePropertyChanged(() => AvailMarginDisplay);
                RaisePropertyChanged(() => RiskRatioDisplay);
            }
        }

        /// <summary>
        /// 期末净值
        /// </summary>      
        private decimal _currentNetWorth;

        /// <summary>
        /// 风控净值(期末净值)
        /// </summary>
        // [PropertyDisc("currentNetworth")]
        public decimal CurrentNetWorth
        {
            get
            {
                //净值 = 期末余额+浮动盈亏 = 占用+可用+冻结保证金+外部冻结+出金冻结+交收冻结+期间冻结金额  (旧的)
                //return Math.Round(CurrentBalance + FloatPL, c_figures, MidpointRounding.AwayFromZero);
           
//#35141与风控确认，风控计算净值时减掉了部分冻结的资金，现在客户端作同步：

//仅全额模式时
//净值=期末余额+市值- 出金冻结 - 交易费用冻结 - 发售冻结 - 交收冻结 - 摘牌冻结 - 托管冻结 - 挂牌冻结；
//无风险率

//仅保证金模式时
//净值=期末余额+浮动盈亏- 出金冻结 - 交易费用冻结 - 发售冻结 - 交收冻结 - 摘牌冻结 - 托管冻结 - 挂牌冻结；
//风险率=【占用/净值】 或 【净值/占用】；

//即有全额又有保证金时
//净值=期末余额+市值+浮动盈亏- 出金冻结 - 交易费用冻结 - 发售冻结 - 交收冻结 - 摘牌冻结 - 托管冻结 - 挂牌冻结；
//风险率=【占用/（净值-市值）】或【（净值-市值）/占用】

                // var v = Math.Round(CurrentBalance + FloatPL - OutAmountFreeze - IMFreezeMargin - DeliveryFreeze - DepositFreeze - DelistingFREEZE - ListingFREEZE - Trade_FEEFREEZE, c_figures, MidpointRounding.AwayFromZero);
                // 错误 #90740 权益不减出金冻结
                var v = Math.Round(CurrentBalance + FloatPL - IMFreezeMargin - DeliveryFreeze - DepositFreeze - DelistingFREEZE - ListingFREEZE - Trade_FEEFREEZE, c_figures, MidpointRounding.AwayFromZero);
                
                return v;
            }
        }



        public string CurrentNetWorthDisplay
        {
            get
            {
                //净值 = 期末余额+浮动盈亏 = 占用+可用+冻结保证金+外部冻结+出金冻结+交收冻结+期间冻结金额
                var value = CurrentNetWorth;
                RaisePropertyChanged(() => SumCurrentNetWorthDisplay);  //更新总净值
                return value.ToString("N" + c_figures);
                //if (value > 0) return value.ToString("N" + c_figures);
                //return "0.00";
            }
        }

        private decimal _payNetWorth;

        /// <summary>
        /// 全额市值
        /// </summary>
        public decimal PayNetWorth
        {
              get
            {
                return _payNetWorth;
            }
            set
            {
                Set(() => PayNetWorth, ref _payNetWorth, value);
                RaisePropertyChanged(() => SumCurrentNetWorthDisplay);  //更新总净值
                RaisePropertyChanged(() => PayNetWorthDisplay);  //全额市值格式化
            }
        }
        /// <summary>
        /// 全额市值格式化
        /// </summary>
        public string PayNetWorthDisplay
        {
            get
            {
                return (PayNetWorth).ToString("N" + c_figures);
            }
        }

        

        /// <summary>
        /// 净值(总净值=风控净值+市值) 期末余额+市值+浮动盈亏；
        /// </summary>
        public decimal SumCurrentNetWorth
        {
            get
            {
                return (PayNetWorth + CurrentNetWorth);
            }
        }


        public string SumCurrentNetWorthDisplay
        {
            get
            {
                return SumCurrentNetWorth.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// 冻结保证金
        /// </summary>      
        private decimal _freezeMargin;

        /// <summary>
        /// 冻结保证金
        /// </summary>
        [PropertyDisc("freezeMargin")]
        public decimal FreezeMargin
        {
            get
            {

                return _freezeMargin;

            }
            set
            {
                Set(() => FreezeMargin, ref _freezeMargin, value);
                RaisePropertyChanged(() => SumFreezeMarginDisplay);

            }
        }

        private decimal _deliveryFreeze;

        /// <summary>
        /// 交收冻结保证金
        /// </summary>
        [PropertyDisc("DELIVERYFREEZE")]
        public decimal DeliveryFreeze
        {
            get
            {

                return _deliveryFreeze;

            }
            set
            {
                _deliveryFreeze = value;
            }
        }

        private decimal _outMouneyThreshold;

        /// <summary>
        /// 出金阀值
        /// 
        /// </summary>
        [PropertyDisc("outMoneyThreshold")]
        public decimal OutThreshold
        {
            get
            {

                return _outMouneyThreshold;

            }
            set
            {
                _outMouneyThreshold = value;
            }
        }

        /// <summary>
        /// 入金金额
        /// </summary>      
        private decimal _inAmount;

        /// <summary>
        /// 入金金额
        /// </summary>
        [PropertyDisc("inAmount")]
        public decimal InAmount
        {
            get
            {

                return _inAmount;

            }
            set
            {
                Set(() => InAmount, ref _inAmount, value); 
                RaisePropertyChanged(()=>InAmountDisplay);
            }
        }



        /// <summary>
        /// 最高利用保证金
        /// </summary>      
        private decimal _maxUsedMargin;

        /// <summary>
        /// 最高利用保证金
        /// </summary>
        public decimal MaxUsedMargin
        {
            get { return _maxUsedMargin; }
            set { Set(() => MaxUsedMargin, ref _maxUsedMargin, value); }
        }

        /// <summary>
        /// 期初净值
        /// </summary>      
        private decimal _netWorth;

        /// <summary>
        /// 期初净值
        /// </summary>
        [PropertyDisc("networth")]
        public decimal NetWorth
        {
            get { return _netWorth; }
            set { Set(() => NetWorth, ref _netWorth, value); }
        }

        /// <summary>
        /// 出金金额
        /// </summary>      
        private decimal _outAmount;

        /// <summary>
        /// 出金金额
        /// </summary>
        [PropertyDisc("outAmount")]
        public decimal OutAmount
        {
            get
            {

                return _outAmount;

            }
            set
            {
                Set(() => OutAmount, ref _outAmount, value); 
                RaisePropertyChanged(()=>OutAmountDisplay);
            }
        }

        /// <summary>
        /// 结算盈亏
        /// </summary>      
        private decimal _reckonPL;

        /// <summary>
        /// 结算盈亏
        /// </summary>
        [PropertyDisc("reckonPL")]
        public decimal ReckonPL
        {
            get
            {

                return _reckonPL;

            }
            set { Set(() => ReckonPL, ref _reckonPL, value); }
        }

        /// <summary>
        /// 当前银行利率
        /// </summary>
        public decimal BankRate { get; set; }

        //浮动盈亏
        private decimal _floatPL;

        /// <summary>
        /// 浮动盈亏(不包括全额)
        /// </summary>
        public decimal FloatPL
        {
            get
            {
                return _floatPL;
            }

            set
            {
                Set(() => FloatPL, ref _floatPL, value);
                RaisePropertyChanged(() => CurrentNetWorth);
                RaisePropertyChanged(() => CurrentNetWorthDisplay);
                RaisePropertyChanged(() => AvailMargin);
                RaisePropertyChanged(() => AvailMarginDisplay);
                RaisePropertyChanged(() => RiskRatioDisplay);
                RaisePropertyChanged(() => BalanceDisplay);
                if (this.TradeAccount != null)
                {
                    RaisePropertyChanged(() => this.TradeAccount.FundsUsageRate);
                }
                RaisePropertyChanged(() => FloatPLBrush);
                RaisePropertyChanged(()=>FloatPLDisplay);
                RaisePropertyChanged(() => SumCurrentNetWorthDisplay);  //更新总净值
            }
        }

        /// <summary>
        /// 可用资金
        /// </summary>
        public decimal AvailAmount { get; set; }

        public Brush FloatPLBrush
        {
            get
            {
                try
                {
                    if (_floatPL == 0)
                    {
                        return ResourceHelper.GetFromResource<Brush>("AccountTextForeground");
                    }
                    else if (_floatPL > 0)
                    {
                        return ResourceHelper.GetFromResource<Brush>("QuoteAscBrush");
                    }
                    else
                    {
                        return ResourceHelper.GetFromResource<Brush>("QuoteDecBrush");
                    }
                }
                catch
                {
                    return null;
                }
            }
        }

        //全额盈亏
        private decimal _payFloatPL;

        /// <summary>
        /// 全额盈亏
        /// </summary>
        public decimal PayFloatPL
        {
            get
            {
                return _payFloatPL;
            }
            set
            {
                Set(() => PayFloatPL, ref _payFloatPL, value);
            }
        }



        /// <summary>
        /// 手续费
        /// </summary>      
        private decimal _tradeCharge;

        /// <summary>
        /// 手续费
        /// </summary>
        public decimal TradeCharge
        {
            get
            {

                return _tradeCharge;

            }
            set { Set(() => TradeCharge, ref _tradeCharge, value); }
        }

        /// <summary>
        /// 资金账号
        /// </summary>
        [PropertyDisc("accountId")]
        public ulong AccountId { get; set; }
        /// <summary>
        /// 交易状态
        /// </summary>
        public uint TradeStatus { get; set; }
        /// <summary>
        /// 是否母账户
        /// </summary>
        public uint IsMain { get; set; }
        /// <summary>
        /// 所属母账户
        /// </summary>
        public ulong ParentAccountID { get; set; }
        /// <summary>
        /// 内、外部
        /// </summary>
        public uint TAAccountType { get; set; }
        /// <summary>
        /// 关联账户
        /// </summary>
        public ulong RelatedMainAccountID { get; set; }

        private decimal _otherFreezeMargin;
        /// <summary>
        /// 其他冻结保证金
        /// </summary>
        public decimal OtherFreezeMargin
        {
            get { return _otherFreezeMargin; }
            set
            {
                Set(() => OtherFreezeMargin, ref _otherFreezeMargin, value);
                RaisePropertyChanged(() => SumFreezeMarginDisplay);
            }
        }

        private decimal _freezeCharge;
        /// <summary>
        /// 手续费冻结
        /// </summary>
        public decimal FreezeCharge
        {
            get { return _freezeCharge; }
            set
            {
                Set(() => FreezeCharge, ref _freezeCharge, value);
                RaisePropertyChanged(() => FreezeChargeDisplay);
            } 
        }
        /// <summary>
        /// 授信金额
        /// </summary>
        public decimal MortgageCredit { get; set; }
        /// <summary>
        /// 其它授信金额
        /// </summary>
        public decimal OtherCredit { get; set; }

        private decimal _payCharge;
        /// <summary>
        /// 今日手续费支出
        /// </summary>
        //public decimal PayCharge { get; set; }
        public decimal PayCharge
        {
            get
            {

                return _payCharge;

            }
            set
            {
                Set(() => PayCharge, ref _payCharge, value);
                RaisePropertyChanged(() => PayChargeDisplay);
            }
        }
        /// <summary>
        /// 今日授信增加
        /// </summary>
        public decimal CreditIncrease { get; set; }
        /// <summary>
        /// 今日授信减少
        /// </summary>
        public decimal CreditDecrease { get; set; }
        /// <summary>
        /// 今日其它授信增加
        /// </summary>
        public decimal OtherCreditIncrease { get; set; }
        /// <summary>
        /// 今日其它授信减少
        /// </summary>
        public decimal OtherCreditDecrease { get; set; }
        /// <summary>
        /// 今日划转金额
        /// </summary>
        public decimal TransferAmount { get; set; }
        /// <summary>
        /// 其他支出
        /// </summary>
        public decimal OtherPay { get; set; }
        /// <summary>
        /// 其他收入
        /// </summary>
        public decimal OtherIncome { get; set; }
        /// <summary>
        /// 占用保证金
        /// </summary>      
        private decimal _usedMargin;

        /// <summary>
        /// 占用保证金
        /// </summary>
        [PropertyDisc("usedMargin")]
        public decimal UsedMargin
        {
            get
            {

                return _usedMargin;

            }
            set
            {
                Set(() => UsedMargin, ref _usedMargin, value);
            }
        }

        /// <summary>
        /// 发售冻结保证金
        /// </summary>
        [PropertyDisc("IMFREEZEMARGIN")]
        public decimal IMFreezeMargin { get; set; }

        /// <summary>
        /// 混合冻结保证金
        /// </summary>
        [PropertyDisc("XMFREEZEMARGIN")]
        public decimal XMFreezeMargin { get; set; }


        /// <summary>
        /// OTC冻结保证金
        /// </summary>
        [PropertyDisc("MMFREEZEMARGIN")]
        public decimal MMFreezeMargin { get; set; }


        /// <summary>
        /// 竞价冻结保证金
        /// </summary>
        [PropertyDisc("BMFREEZEMARGIN")]
        public decimal BMFreezeMargin { get; set; }


        /// <summary>
        /// 外部冻结
        /// </summary>
        [PropertyDisc("OTRFREEZE")]
        public decimal OTRFreezeMargin { get; set; }

        /// <summary>
        /// OTC占用保证金
        /// </summary>
        [PropertyDisc("MMUSEDMARGIN")]
        public decimal MMUsedMargin { get; set; }

        /// <summary>
        /// 混合占用保证金
        /// </summary>
        [PropertyDisc("XMUSEDMARGIN")]
        public decimal XMUsedMargin { get; set; }

        /// <summary>
        /// 竞价占用保证金
        /// </summary>
        [PropertyDisc("BMUSEDMARGIN")]
        public decimal BMUsedMargin { get; set; }

        /// <summary>
        /// 发售手续费
        /// </summary>
        [PropertyDisc("IMTRADEFEE")]
        public decimal IMTradeFee { get; set; }

        /// <summary>
        /// 混合手续费
        /// </summary>
        [PropertyDisc("XMTRADEFEE")]
        public decimal XMTradeFee { get; set; }

        /// <summary>
        /// 即期手续费
        /// </summary>
        [PropertyDisc("MMTRADEFEE")]
        public decimal MMTradeFee { get; set; }

        /// <summary>
        /// 竞价手续费
        /// </summary>
        [PropertyDisc("BMTRADEFEE")]
        public decimal BMTradeFee { get; set; }

        /// <summary>
        /// 账号所属机构角色
        /// </summary>
        [PropertyDisc("AreaRoles")]
        public int AreaRoles { get; set; }


        /// <summary>
        /// 挂牌手续费
        /// </summary>
        [PropertyDisc("ListingFee")]
        public decimal ListingFee { get; set; }

        /// <summary>
        /// 摘牌手续费
        /// </summary>
        [PropertyDisc("DelistingFee")]
        public decimal DelistingFee { get; set; }

        /// <summary>
        /// 摘牌冻结
        /// </summary>
        [PropertyDisc("DelistingFREEZE")]
        public decimal DelistingFREEZE { get; set; }


            /// <summary>
        /// 挂牌冻结
        /// </summary>
        [PropertyDisc("ListingFREEZE")]
        public decimal ListingFREEZE { get; set; }
         

        /// <summary>
        /// 托管冻结
        /// </summary>
        [PropertyDisc("DepositFreeze")]
        public decimal DepositFreeze { get; set; }

     

        private decimal _SumFreezeMargin = decimal.Zero;

        /// <summary>
        /// 总冻结保证金
        /// </summary>
        public decimal SumFreezeMargin
        {
            get
            {
                //return TASumFreezeMargin + OTRFreezeMargin + OutAmountFreeze;

                //MTP2.0变更字段
                return FreezeMargin + OtherFreezeMargin + OutAmountFreeze;
            }
        }

        

        /// <summary>
        /// 总冻结保证金格式化
        /// </summary>
        public string SumFreezeMarginDisplay
        {
            get
            {
                return SumFreezeMargin.ToString("N" + c_figures);
            }
        }

        

        /// <summary>
        /// 总交易手续费
        /// </summary>
        public decimal SumTradeFee
        {
            get
            {
                return XMTradeFee + IMTradeFee + MMTradeFee + BMTradeFee;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public string UsedMarginDisplay
        {
            get
            {
                return UsedMargin.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// (会员风控) 风险率
        /// </summary>
        public decimal RiskRatio
        {
            get
            {
                decimal rate = -100;
                switch (TradeAccount.RiskRatioCalcMode)
                {
                    case eRiskRateMode.WORTHOCCUPY:
                        if (UsedMargin == 0)
                        {
                            return 0;
                        }
                        rate=(CurrentNetWorth / UsedMargin);
                        break;
                    default:
                        if (CurrentNetWorth == 0)
                        {
                            return 0;
                        }
                        rate=(UsedMargin / CurrentNetWorth);
                        break;
                }
                if (rate < 0)
                {
                    rate = -100;
                }
                return rate;
            }
        }

        /// <summary>
        /// 风险率
        /// </summary>
        public string RiskRatioDisplay
        {
            get
            {  
                if (TradeAccount == null)
                {
                    return "--";
                }
                decimal rate = -100;
                switch (TradeAccount.RiskRatioCalcMode)
                {
                       
                    case eRiskRateMode.WORTHOCCUPY:
                        if (UsedMargin == 0)
                        {
                            return "--";
                        }
                        rate= (CurrentNetWorth / UsedMargin) ;
                        break;
                    default:
                        if (CurrentNetWorth == 0)
                        {
                            return "--";
                        }
                        rate= (UsedMargin / CurrentNetWorth) ;
                 break;
                }
                if (rate < 0)
                {
                    return (-100).ToString("P2");
                }
                return rate.ToString("P2");

            }
        }

        /// <summary>
        /// 调整
        /// </summary>
        public decimal Adjust { get; set; }



        private decimal _outAmountFreeze;

        /// <summary>
        /// 出金冻结保证金
        /// </summary>
        [PropertyDisc("OutMoneyFreeze")]
        public decimal OutAmountFreeze
        {
            get
            {
                return _outAmountFreeze;
            }
            set
            {
                Set(() => OutAmountFreeze, ref _outAmountFreeze, value);
                RaisePropertyChanged(() => SumFreezeMarginDisplay);
            }
        }

        /// <summary>
        /// 最大合约价格
        /// </summary>
        [PropertyDisc("maxAgreeAmount")]
        public decimal MaxAgreeAmount
        {
            get;
            set;
        }






        #endregion Properties

        /// <summary>
        /// 所属交易账号
        /// </summary>
        public TradeAccount TradeAccount { get; set; }

        /// <summary>
        /// 显示用户状态
        /// </summary>
        public string AccountStatusDisplay
        {
            get
            {
                return AccountStatus.Discription();
            }
        }
        /// <summary>
        /// 会员证件类型
        /// </summary>
        public eCardType CardType { get; set; }

        /// <summary>
        /// 会员证件号码
        /// </summary>
        public string CardNum { get; set; }
       
        
        

        public override string ToString()
        {
            string strbuff = Client_Resource.Domain_Account + this.AccountId + Client_Resource.Domain_AvailableFunds +
                             this.AvailMargin + Client_Resource.Domain_RiskRatio + this.RiskRatioDisplay;
            return strbuff;
        }

        /// <summary>
        /// 冻结保证金(总冻结)(数据库查询不包括出金冻结)
        /// </summary>
        [PropertyDisc("TASumFreezeMargin")]
        public decimal TASumFreezeMargin
            {
            get;
            set;
            }

        /// <summary>
        /// 仓单冲抵最低保证金
        /// </summary>
        [PropertyDisc("mincurrentbalance")]
        public decimal MincurrentBalance
                {
            get;
            set;
                }

        /// <summary>
        /// 人工冻结
        /// </summary>
        [PropertyDisc("ManualFreeze")]
        public decimal ManualFreeze { get; set; }

        /// <summary>
        /// 当天入金是否可出 0：不可出 1：可出
        /// </summary>
        [PropertyDisc("IsAllowInMoney")]
        public int IsAllowInMoney
                {
            get;
            set;
        }

        /// <summary>
        /// 交易费用冻结
        /// </summary>
          [PropertyDisc("Trade_FEEFREEZE")]
        public decimal Trade_FEEFREEZE { get; set; }

        
       // public eAccountStatus AccountStatus { get; set; }

        private eAccountStatus _accountStatus;
        /// <summary>
        /// 账号状态
        /// </summary>
        [PropertyDisc("accountstatus")]
        public eAccountStatus AccountStatus
        {
            get 
            {
                return _accountStatus; 
            }
            set 
            { 
                _accountStatus = value;
            }
        }


        /// <summary>
        /// Gets or sets the currency identifier.
        /// </summary>
        /// <value>The currency identifier.</value>
        public uint CurrencyID { get; set; }

        /// <summary>
        /// 冻结手续费
        /// </summary>
        /// <value>The freeze charge display.</value>
        public string FreezeChargeDisplay
        {
            get
            {
                return FreezeCharge.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// 入金
        /// </summary>
        /// <value>The freeze charge display.</value>
        public string InAmountDisplay
        {
            get
            {
                return InAmount.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// 出金
        /// </summary>
        /// <value>The freeze charge display.</value>
        public string OutAmountDisplay
        {
            get
            {
                return OutAmount.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// Gets the close pl display.
        /// </summary>
        /// <value>The close pl display.</value>
        public string ClosePLDisplay
        {
            get
            {
                return ClosePL.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// Gets the float pl display.
        /// </summary>
        /// <value>The float pl display.</value>
        public string FloatPLDisplay
        {
            get
            {
                return FloatPL.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// Gets the pay charge display.
        /// </summary>
        /// <value>The pay charge display.</value>
        public string PayChargeDisplay
        {
            get
            {
                return PayCharge.ToString("N" + c_figures);
            }
        }

        /// <summary>
        /// Gets the freeze margin display.
        /// </summary>
        /// <value>The freeze margin display.</value>
        public string FreezeMarginDisplay
        {
            get
            {
                return FreezeMargin.ToString("N" + c_figures);
            }
        }
        /// <summary>
        /// Gets the close pl brush.
        /// </summary>
        /// <value>The close pl brush.</value>
        public Brush ClosePLBrush
        {
            get
            {
                try
                {
                    if (_closePL == 0)
                    {
                        return ResourceHelper.GetFromResource<Brush>("AccountTextForeground");
                    }
                    else if (_closePL > 0)
                    {
                        return ResourceHelper.GetFromResource<Brush>("QuoteAscBrush");
                    }
                    else
                    {
                        return ResourceHelper.GetFromResource<Brush>("QuoteDecBrush");
                    }
                }
                catch
                {
                    return null;
                }
            }
        }

        private bool _floatAvaliabelFlag;

        public bool FloatAvaliabelFlag
        {
            get
            {

                return _floatAvaliabelFlag;

            }
            set
            {
                Set(() => FloatAvaliabelFlag, ref _floatAvaliabelFlag, value);
                RaisePropertyChanged(() => AvailMarginDisplay);
            }
        }
    }
}