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

using System.Collections.Generic;
using System.Windows.Documents;
using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Helper;
using System;
using System.Windows;
using Muchinfo.MTPClient.Infrastructure.Utilities;

namespace Muchinfo.MTPClient.Data.Model.Account
{
    /// <summary>
    /// 持仓汇总
    /// </summary>
    public class HoldingSummary : OrderBase,ICloneable
    {
        [PropertyDisc("AccountID")]
        public ulong AccountId
        {
            get;
            set;
        }

        /// <summary>
        /// 期初持仓数量
        /// </summary>      
        private decimal _positionQty;
        /// <summary>
        /// 期初持仓数量
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        [PropertyDisc("PositionQty")]
        public decimal PositionQty
        {
            get { return _positionQty; }
            set { Set(() => PositionQty, ref _positionQty, value); }
        }
        /// <summary>
        /// 期初持仓总金额
        /// </summary>
        private decimal _holderAmount;
        /// <summary>
        /// 期初持仓总金额
        /// </summary>
        [PropertyDisc("HolderAmount")]
        public decimal HolderAmount
        {
            get { return _holderAmount; }
            set { Set(() => HolderAmount, ref _holderAmount, value); }
        }

        /// <summary>
        /// 当前持仓总金额
        /// </summary>      
        private decimal _curHolderAmount;
        /// <summary>
        /// 当前持仓总金额
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        [PropertyDisc("CurHolderAmount")]
        public decimal CurHolderAmount
        {
            get { return _curHolderAmount; }
            set
            {
                Set(() => CurHolderAmount, ref _curHolderAmount, value);
                RaisePropertyChanged(() => GoodsPaymentDisplay);
                RaisePropertyChanged(() => ProfitPercen);
            }
        }

        /// <summary>
        /// 当前持仓数量
        /// </summary>      
        private decimal _lot;
        /// <summary>
        /// 当前持仓数量
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        [PropertyDisc("CurPositionQty")]
        public decimal Lot
        {
            get { return _lot; }
            set
            {
                Set(() => Lot, ref _lot, value);
                RaisePropertyChanged(() => AvailQty);
            }
        }

        private decimal _availQty;
        public decimal AvailQty
        {
            get
            {
                _availQty = _lot - _frozenQty - _otherFrozenQty;
                return _availQty;
            }
        }
        /// <summary>
        /// 持仓冻结数量
        /// </summary>      
        private decimal _frozenQty;
        /// <summary>
        /// 持仓冻结数量
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        [PropertyDisc("FrozenQty")]
        public decimal FrozenQty
        {
            get { return _frozenQty; }
            set
            {
                Set(() => FrozenQty, ref _frozenQty, value);
                RaisePropertyChanged(() => AvailQty);
            }
        }

        /// <summary>
        /// 其他冻结数量
        /// </summary>
        private decimal _otherFrozenQty;
        /// <summary>
        /// 其他冻结数量
        /// </summary>
        [PropertyDisc("OtherFrozenQty")]
        public decimal OtherFrozenQty
        {
            get { return _otherFrozenQty; }
            set
            {
                Set(() => OtherFrozenQty, ref _otherFrozenQty, value);
                RaisePropertyChanged(() => AvailQty);
            }
        }
        private decimal _openReqQty;
        [PropertyDisc("OpenReqQty")]
        public decimal OpenReqQty
        {
            get { return _openReqQty; }
            set { Set(() => OpenReqQty, ref _openReqQty, value); }
        }
        private decimal _openTotalQty;
        [PropertyDisc("OpenTotalQty")]
        public decimal OpenTotalQty
        {
            get { return _openTotalQty; }
            set { Set(() => OpenTotalQty, ref _openTotalQty, value); }
        }
        private decimal _closeTotalQty;
        [PropertyDisc("CloseTotalQty")]
        public decimal CloseTotalQty
        {
            get { return _closeTotalQty; }
            set { Set(() => CloseTotalQty, ref _closeTotalQty, value); }
        }

        /// <summary>
        /// 获取或设置  持仓均价
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>   
        public decimal HoldingAVGPrice
        {
            get { return _curHolderAmount / _lot / AgreeUnit; }
        }
        /// <summary>
        /// 显示持仓均价
        /// </summary>
        public string DisplayHoldingAVGPrice
        {
            get
            {
                if (HoldingAVGPrice > 0)
                {
                    return HoldingAVGPrice.ToString(PriceFormat);
                }
                else
                {
                    return "-";
                }
            }
        }
        [PropertyDisc("AgreeUnit")]
        public decimal AgreeUnit { get; set; }

        /// <summary>
        /// 最新价
        /// </summary>      
        private decimal _latestPrice;

        /// <summary>
        /// 获取或设置 最新价
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        public decimal LatestPrice
        {
            get
            {
                return _latestPrice;
            }

            set
            {
                Set(() => LatestPrice, ref _latestPrice, value);
                RaisePropertyChanged(() => DisplayLatestPrice);
                RaisePropertyChanged(() => MarketValue);
            }
        }

        /// <summary>
        /// 显示最新价
        /// </summary>
        public string DisplayLatestPrice
        {
            get
            {

                if (LatestPrice > 0)
                {
                    return LatestPrice.ToString(PriceFormat);
                }
                else
                {
                    return "-";
                }
            }
        }

        /// <summary>
        /// 浮动盈亏
        /// </summary>      
        private decimal _pLFloat;

        /// <summary>
        /// 获取或设置 浮动盈亏
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        public decimal PLFloat
        {
            get
            {
                return _pLFloat;
            }

            set
            {
                Set(() => PLFloat, ref _pLFloat, value);
                RaisePropertyChanged(() => DisplayPLFloat);
                //RaisePropertyChanged(() => SumFloatPL);
                // 错误 #92030 浮动盈亏
                RaisePropertyChanged(() => ProfitLossOpenDisplay);
            }
        }

        /// <summary>
        /// 浮动盈亏（计算商品目标汇率后，主要用于资金账户盈亏计算）
        /// </summary>
        private decimal _pLFloatWithRate;

        /// <summary>
        /// 浮动盈亏（计算商品目标汇率后，主要用于资金账户盈亏计算）
        /// </summary>
        public decimal PLFloatWithRate
        {
            get { return _pLFloatWithRate; }
            set
            {
                Set(() => PLFloatWithRate, ref _pLFloatWithRate, value);
            }
        }

        /// <summary>
        /// 显示 浮动盈亏
        /// </summary>
        public string DisplayPLFloat
        {
            get
            {
                if (PLFloat != decimal.Zero)
                {
                    return PLFloat.ToString("N2");
                }
                else
                {
                    return "-";
                }

            }
        }

        /// <summary>
        /// 平仓价
        /// </summary>      
        private decimal _closePrice;

        /// <summary>
        /// 获取或设置 平仓价
        /// Changes to that property's value raise the PropertyChanged event. 
        /// </summary>
        public decimal ClosePrice
        {
            get
            {
                return _closePrice;
            }

            set
            {
                Set(() => ClosePrice, ref _closePrice, value);
                RaisePropertyChanged(() => DisplayClosePrice);
            }
        }

        /// <summary>
        /// 显示平仓价格
        /// </summary>
        public string DisplayClosePrice
        {
            get
            {

                //if (ClosePrice > 0 && MarketType != eTradeMode.TRADEMODE_SALE)
                if (ClosePrice > 0)
                {
                    return ClosePrice.ToString(PriceFormat);
                }
                else
                {
                    return "-";
                }
            }
        }

        /// <summary>
        /// 显示建仓日期
        /// </summary>
        public string StrOpenDirection
        {
            get
            {
                return Direction.Discription();
                //switch (OpenDirection)
                //{
                //    case Direction.Ask:
                //        return Client_Resource.Domain_SellOut;
                //    case Direction.Bid:
                //        return Client_Resource.Domain_BuyIn;
                //    default:
                //        return Client_Resource.Domain_BuyIn;
                //}
            }
        }


        public eTradeMode TradeMode { get; set; }


        /// <summary>
        /// Gets a value indicating whether this instance is can close.
        /// </summary>
        /// <value><c>true</c> if this instance is can close; otherwise, <c>false</c>.</value>
        public bool IsCanClose
        {
            get
            {
                var canClose = ShowCloseOrder;
                //return TradeMode != eTradeMode.TRADEMODE_SALE;
                return AvailQty > 0 && canClose;
                //return true;
            }
        }

        /// <summary>
        /// Config.xml配置参数：是否显示平仓
        /// </summary>
        /// <value><c>true</c> if [show close order]; otherwise, <c>false</c>.</value>
        public bool ShowCloseOrder { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is can SPSL.
        /// </summary>
        /// <value><c>true</c> if this instance is can SPSL; otherwise, <c>false</c>.</value>
        public bool IsCanSPSL
        {
            get
            {
                //todo:通过服务配置控制
                var canSPSL = SystemParamManager.IsCanSPSL;
                return AvailQty > 0 && canSPSL;
            }
        }

        #region 添加锁仓数量
        ///// <summary>
        ///// 锁仓数量
        ///// </summary>
        //public decimal LockQty { get; set; }

        ///// <summary>
        ///// 持仓总量
        ///// </summary>
        //public decimal TotalLot
        //{
        //    get { return Lot + LockQty; }
        //}
        #endregion

        /// <summary>
        /// 持仓单
        /// </summary>
        public List<HoldingOrder> Holders
        {
            get; set;
        }

        private decimal _sumFloatPL;

        /// <summary>
        /// 盈亏汇总
        /// </summary>
        public decimal SumFloatPL
        {
            get { return _sumFloatPL; }
            set { Set(() => SumFloatPL, ref _sumFloatPL, value); }
        }


        private decimal _goodsPayment;

        /// <summary>
        /// 货款=持仓价*持有总量*合约单位
        /// </summary>
        public decimal GoodsPayment
        {
            get { return _goodsPayment; }
            set
            {
                Set(() => GoodsPayment, ref _goodsPayment, value);
                RaisePropertyChanged(() => GoodsPaymentDisplay);
                RaisePropertyChanged(() => ProfitPercen);
            }
        }

        public string GoodsPaymentDisplay
        {
            get
            {
                if (GoodsPayment != 0)
                {
                    return GoodsPayment.ToString("f2");
                }
                else
                {
                    return "-";
                }
            }
        }


        private decimal _marketValue;

        /// <summary>
        /// 市值=最新价*持有总量*合约单位；
        /// </summary>
        public decimal MarketValue
        {
            get { return _marketValue; }
            set
            {
                Set(() => MarketValue, ref _marketValue, value);
                RaisePropertyChanged(() => MarketValueDisplay);
                RaisePropertyChanged(() => ProfitPercen);
            }
        }

        public string MarketValueDisplay
        {
            get
            {
                if (MarketValue != 0)
                {
                    return MarketValue.ToString("f2");
                }
                else
                {
                    return "-";
                }
            }
        }

        /// <summary>
        /// 盈亏比例=（市值—货款）/ 货款 * 100% ；
        /// </summary>
        public string ProfitPercen
        {
            get
            {
                if (GoodsPayment != 0 && MarketValue != 0)
                {

                    return ((MarketValue - GoodsPayment) / GoodsPayment).ToString("P2");
                }
                else
                {
                    return "-";
                }

            }
        }

        /// <summary>
        /// 可平数量
        /// </summary>
        public decimal CloseQty {
            get
            {
                return Math.Min((TnAvailQty - TnFreezeqty), (AvailQty));
            } }


        /// <summary>
        /// T+N 冻结
        /// </summary>
        public decimal TnFreezeqty { get; set; }

        /// <summary>
        /// 达到T＋N的持仓数量(包括T+N冻结)
        /// </summary>
        public decimal TnAvailQty { get; set; }


        /// <summary>
        /// 是否显示交割
        /// </summary>
        public bool IsShowDelivery { get; set; }

        /// <summary>
        /// 价格小数位
        /// </summary>
        public int DecimalPlace { get; set; }

        //public override string PriceExpFormat
        //{
        //    get
        //    {
        //        if (DecimalPlace < 3)
        //        {
        //            return "F2";
        //        }
        //        else
        //        {
        //            return PriceFormat;
        //        }
        //    }
        //}

        //public override string PriceFormat
        //{
        //    get
        //    {
        //        if (DecimalPlace >= 0 && DecimalPlace < 20)
        //        {
        //            return "F" + DecimalPlace;
        //        }
        //        else
        //        {
        //            return "F2";
        //        }
        //    }
        //}

        [PropertyDisc("UsedMargin")]
        public decimal UsedMargin
        {
            get;
            set;
        }

        public string UsedMarginDisplay
        {
            get { return UsedMargin.ToString("f2"); }
        }


        /// <summary>
        /// 昨结价
        /// </summary>
        private decimal _preClosePrice;
        /// <summary>
        /// 结算价
        /// </summary>
        private decimal _preSettlePrice;


        [PropertyDisc("PreClosePrice")]
        public decimal PreClosePrice
        {
            get { return _preClosePrice; }
            set { Set(() => PreClosePrice, ref _preClosePrice, value); }
        }
        [PropertyDisc("PreSettlePrice")]
        public decimal PreSettlePrice
        {
            get { return _preClosePrice; }
            set { Set(() => PreSettlePrice, ref _preSettlePrice, value); }
        }
        public string PreClosePriceDisplay
        {
            get { return PreClosePrice.ToString(PriceFormat); }
        }

        public string PreSettlePriceDisplay
        {
            get { return PreSettlePrice.ToString(PriceFormat); }
        }

        public object Clone()
        {
            return MemberwiseClone();
        }

        /// <summary>
        /// 开仓均价
        /// </summary>
        private decimal _openAvaPrice;
        public decimal OpenAvaPrice
        {
            get { return _openAvaPrice; }
            set
            {
                if (value != 0)
                {
                    _openAvaPrice = value;
                }
            }
        }

        public string OpenAvaPriceDisplay
        {
            get
            {
                return OpenAvaPrice.ToString(PriceFormat);
            }
        }

        private decimal _openProfitLoss;

        /// <summary>
        /// 开仓浮动盈亏
        /// </summary>
        public decimal OpenProfitLoss
        {
            get { return _openProfitLoss; }
            set { _openProfitLoss = value; }
        }

        /// <summary>
        /// 浮动盈亏=+/-（当前市价-开仓均价）*持仓数量*合约单位*汇率，买方向为正，卖方向为负
        /// </summary>
        public string ProfitLossOpenDisplay
        {
            get
            {
                if (_openProfitLoss == 0)
                {
                    return "-";
                }
                return _openProfitLoss.ToString("f2");
            }
        }
    }
}