//Only Update the fields that should take effect in the past
internal override void Update(IDBRow instrumentRow)
{
base.Update(instrumentRow);
this._category = (InstrumentCategory)instrumentRow.GetColumn <int>("Category");
this._numeratorUnit = instrumentRow.GetColumn <int>("NumeratorUnit");
this._denominator = instrumentRow.GetColumn <int>("Denominator");
this._isNormal = instrumentRow.GetColumn <bool>("IsNormal");
this.DayOpenTime = (instrumentRow["DayOpenTime"] == DBNull.Value) ? default(DateTime) : (DateTime)instrumentRow["DayOpenTime"];
this.DayCloseTime = (instrumentRow["DayCloseTime"] == DBNull.Value) ? default(DateTime) : (DateTime)instrumentRow["DayCloseTime"];
if (instrumentRow.Contains("EndTime"))
{
_endTime = (instrumentRow["EndTime"] == DBNull.Value) ? default(DateTime) : (DateTime)instrumentRow["EndTime"];
}
this.ValueDate = (instrumentRow["ValueDate"] == DBNull.Value) ? default(DateTime) : (DateTime)instrumentRow["ValueDate"];
this.NextDayOpenTime = (instrumentRow["NextDayOpenTime"] == DBNull.Value) ? default(DateTime) : (DateTime)instrumentRow["NextDayOpenTime"];
this._commissionFormula = (FeeFormula)instrumentRow.GetColumn <byte>("CommissionFormula");
this._levyFormula = (FeeFormula)instrumentRow.GetColumn <byte>("LevyFormula");
_otherFeeFormula = (FeeFormula)instrumentRow.GetColumn <byte>("OtherFeeFormula");
this._marginFormula = (MarginFormula)instrumentRow.GetColumn <byte>("MarginFormula");
this._tradePLFormula = (TradePLFormula)instrumentRow.GetColumn <byte>("TradePLFormula");
this._isExpired = this.DayOpenTime == default(DateTime) && this.DayCloseTime == default(DateTime) && this.ValueDate == default(DateTime) && this.NextDayOpenTime == default(DateTime);
}
internal static decimal CalculateNecessary(Order order, Quotation quotation, DateTime?tradeDay)
{
MarginFormula marginFormula = order.Owner.SettingInstrument().MarginFormula;
Price price = order.ExecutePrice;
if (marginFormula.MarketPriceInvolved())
{
price = order.IsBuy ? quotation.BuyPrice : quotation.SellPrice;
}
return(NecessaryCalculator.CalculateNecessary(order, price, order.LotBalance, tradeDay));
}
internal static void CalculatePreCheckNecessary(this Order order, MarginFormula marginFormula, CurrencyRate currencyRate, decimal contractSize, Price preCheckPrice, decimal?effectiveLot)
{
if (preCheckPrice != null)
{
var lot = effectiveLot.HasValue ? effectiveLot.Value : order.Lot;
order.PreCheckMargin = NecessaryCalculator.CalculateNecessary(order, marginFormula, lot, contractSize, preCheckPrice, currencyRate);
}
else if (!order.IsPreCheckCalculated)
{
var price = order.SetPrice == null ? order.ExecutePrice : order.SetPrice;
order.PreCheckMargin = NecessaryCalculator.CalculateNecessary(order, marginFormula, order.Lot, contractSize, price, currencyRate);
}
order.IsPreCheckCalculated = true;
}
internal static decimal CalculateNecessary(Order order, Price price, decimal lot, DateTime?tradeDay)
{
MarginFormula marginFormula = order.Owner.SettingInstrument().MarginFormula;
CurrencyRate currencyRate = order.Owner.CurrencyRate(null);
decimal contractSize = order.Owner.ContractSize(tradeDay);
if (price == null)
{
price = order.ExecutePrice;
if (marginFormula.MarketPriceInvolved())
{
price = order.GetLivePriceForCalculateNecessary();
}
}
return(CalculateNecessary(order, marginFormula, lot, contractSize, price, currencyRate));
}
internal static decimal CalculateNecessary(Order order, MarginFormula marginFormula, decimal lotBalance, decimal contractSize, Price price, CurrencyRate currencyRate)
{
if (order.IsRisky)
{
decimal margin = 0;
switch (marginFormula)
{
case MarginFormula.FixedAmount:
margin = lotBalance;
margin = Math.Round(margin, currencyRate.TargetCurrency.Decimals, MidpointRounding.AwayFromZero);
break;
case MarginFormula.CS:
margin = lotBalance * contractSize;
margin = -currencyRate.Exchange(-margin);
break;
case MarginFormula.CSiPrice:
case MarginFormula.CSiMarketPrice:
margin = lotBalance * contractSize / (decimal)price;
margin = -currencyRate.Exchange(-margin);
break;
case MarginFormula.CSxPrice:
case MarginFormula.CSxMarketPrice:
margin = lotBalance * contractSize * (decimal)price;
margin = -currencyRate.Exchange(-margin);
break;
case MarginFormula.FKLI:
case MarginFormula.FCPO:
margin = lotBalance;
margin = Math.Round(margin, currencyRate.TargetCurrency.Decimals, MidpointRounding.AwayFromZero);
break;
default:
throw new NotSupportedException(string.Format("{0} is not a supported MarginFormula", marginFormula));
}
return(margin);
}
else
{
return(0);
}
}
internal virtual ChangedItem Update(Quotation qutation)
{
ChangedItem changedItems = ChangedItem.None;
if (_ask != qutation.Ask || _bid != qutation.Bid)
{
changedItems |= ChangedItem.Quotation;
}
var currencyRate = _owner.Owner.CurrencyRate(null);
var settingInstrument = _owner.Owner.SettingInstrument();
if (_currencyRateIn != currencyRate.RateIn || _currencyRateOut != currencyRate.RateOut)
{
changedItems |= ChangedItem.CurrecnyRate;
}
if (_tradePLFormula != settingInstrument.TradePLFormula)
{
changedItems |= ChangedItem.TradePLFormula;
}
if (_marginFormula != settingInstrument.MarginFormula)
{
changedItems |= ChangedItem.MarginFormula;
}
if (_lotBlance != _owner.LotBalance)
{
changedItems |= ChangedItem.LotBalance;
}
_ask = qutation.Ask;
_bid = qutation.Bid;
_marginFormula = settingInstrument.MarginFormula;
_tradePLFormula = settingInstrument.TradePLFormula;
_lotBlance = _owner.LotBalance;
_currencyRateIn = currencyRate.RateIn;
_currencyRateOut = currencyRate.RateOut;
this.ChangedItem = changedItems;
return(changedItems);
}
internal static bool MarketPriceInvolved(this MarginFormula marginFormula)
{
return(marginFormula == MarginFormula.CSiMarketPrice || marginFormula == MarginFormula.CSxMarketPrice);
}
internal override void Update(XElement instrumentNode)
{
base.Update(instrumentNode);
foreach (XAttribute attribute in instrumentNode.Attributes())
{
switch (attribute.Name.ToString())
{
case "ID":
this._id = XmlConvert.ToGuid(attribute.Value);
break;
case "CurrencyID":
this._currencyId = XmlConvert.ToGuid(attribute.Value);
break;
case "Code":
this._code = attribute.Value;
break;
case "OriginCode":
_originCode = attribute.Value;
break;
case "OriginInactiveTime":
this.InactiveTime = XmlConvert.ToInt32(attribute.Value);
break;
case "Category":
this._category = (InstrumentCategory)XmlConvert.ToInt32(attribute.Value);
break;
case "NumeratorUnit":
this._numeratorUnit = XmlConvert.ToInt32(attribute.Value);
break;
case "Denominator":
this._denominator = XmlConvert.ToInt32(attribute.Value);
break;
case "IsActive":
this._isActive = XmlConvert.ToBoolean(attribute.Value);
break;
case "LastAcceptTimeSpan":
this._lastAcceptTimeSpan = XmlConvert.ToInt32(attribute.Value);
break;
case "OrderTypeMask":
this._orderTypeMask = XmlConvert.ToInt32(attribute.Value);
break;
case "MIT":
this._mit = XmlConvert.ToBoolean(attribute.Value);
break;
case "AutoAcceptMaxLot":
this.AutoAcceptMaxLot = XmlConvert.ToDecimal(attribute.Value);
break;
case "AutoCancelMaxLot":
this.AutoCancelMaxLot = XmlConvert.ToDecimal(attribute.Value);
break;
case "IsAutoFill":
this._isAutoFill = XmlConvert.ToBoolean(attribute.Value);
break;
case "MaxMinAdjust":
this._maxMinAdjust = XmlConvert.ToInt32(attribute.Value);
break;
case "DayOpenTime":
this.DayOpenTime = Convert.ToDateTime(attribute.Value);
break;
case "DayCloseTime":
this.DayCloseTime = Convert.ToDateTime(attribute.Value);
break;
case "EndTime":
_endTime = Convert.ToDateTime(attribute.Value);
break;
case "ValueDate":
this.ValueDate = Convert.ToDateTime(attribute.Value);
break;
case "NextDayOpenTime":
this.NextDayOpenTime = Convert.ToDateTime(attribute.Value);
break;
case "CommissionFormula":
this._commissionFormula = (FeeFormula)XmlConvert.ToByte(attribute.Value);
break;
case "LevyFormula":
this._levyFormula = (FeeFormula)XmlConvert.ToByte(attribute.Value);
break;
case "OtherFeeFormula":
_otherFeeFormula = (FeeFormula)XmlConvert.ToByte(attribute.Value);
break;
case "MarginFormula":
this._marginFormula = (MarginFormula)XmlConvert.ToByte(attribute.Value);
break;
case "TradePLFormula":
this._tradePLFormula = (TradePLFormula)XmlConvert.ToByte(attribute.Value);
break;
case "InterestFormula":
this._interestFormula = (InterestFormula)XmlConvert.ToByte(attribute.Value);
break;
case "InterestYearDays":
this._interestYearDays = XmlConvert.ToInt32(attribute.Value);
break;
case "IsNormal":
this._isNormal = XmlConvert.ToBoolean(attribute.Value);
break;
case "HitTimes":
this._hitTimes = XmlConvert.ToInt32(attribute.Value);
break;
case "PenetrationPoint":
this._penetrationPoint = XmlConvert.ToInt32(attribute.Value);
break;
case "UseSettlementPriceForInterest":
this._useSettlementPriceForInterest = XmlConvert.ToBoolean(attribute.Value);
break;
case "CanPlacePendingOrderAtAnyTime":
this._canPlacePendingOrderAtAnyTime = XmlConvert.ToBoolean(attribute.Value);
break;
case "AllowedSpotTradeOrderSides":
this._allowedSpotTradeOrderSides = (AllowedOrderSides)XmlConvert.ToInt32(attribute.Value);
break;
case "PlaceSptMktTimeSpan":
_placeSptMktTimeSpan = TimeSpan.FromSeconds(XmlConvert.ToInt32(attribute.Value));
break;
case "HitPriceVariationForSTP":
this.HitPriceVariationForSTP = XmlConvert.ToInt32(attribute.Value);
break;
case "AcceptIfDoneVariation":
this._acceptIfDoneVariation = XmlConvert.ToInt32(attribute.Value);
break;
case "FirstOrderTime":
_firstOrderTime = XmlConvert.ToInt32(attribute.Value);
break;
case "IsPriceEnabled":
this._isPriceEnabled = XmlConvert.ToBoolean(attribute.Value);
_priceEnableTime = DateTime.Now;
break;
case "AutoDQDelay":
this.AutoDQDelay = TimeSpan.FromSeconds(XmlConvert.ToInt16(attribute.Value));
break;
case "HolidayAlertDayPolicyID":
this.HolidayAlertDayPolicyId = XmlConvert.ToGuid(attribute.Value);
break;
case "SummaryQuantity":
this._summaryQuantity = XmlConvert.ToDecimal(attribute.Value);
break;
case "SpotPaymentTime":
this.SpotPaymentTime = attribute.Value.Get <DateTime?>();
break;
}
}
}
public void CalculateNetAndHedgeNecessary(decimal buyNecessarySum, decimal sellNecessarySum,
decimal buyQuantitySum, decimal sellQuantitySum, ref decimal partialPhysicalNecessarySum,
out decimal netNecessary, out decimal hedgeNecessary)
{
bool shouldUseDayNecessary = _owner.Trading.ShouldUseDayNecessary;
partialPhysicalNecessarySum = partialPhysicalNecessarySum * this.GetTradePolicyDetail().PartPaidPhysicalNecessary
*(shouldUseDayNecessary ? _owner.Owner.Setting().RateMarginD : _owner.Owner.Setting().RateMarginO);
netNecessary = hedgeNecessary = 0;
MarginFormula marginFormula = _owner.Setting.MarginFormula;
if (marginFormula == MarginFormula.CSiPrice || marginFormula == MarginFormula.CSxPrice ||
marginFormula == MarginFormula.CSiMarketPrice || marginFormula == MarginFormula.CSxMarketPrice)
{
decimal buyNecessaryAvarage = buyQuantitySum == 0 ? 0 : buyNecessarySum / buyQuantitySum;
decimal sellNecessaryAvarage = sellQuantitySum == 0 ? 0 : sellNecessarySum / sellQuantitySum;
decimal hedgeQuantity = Math.Min(buyQuantitySum, sellQuantitySum);
decimal netQuantity = Math.Abs(buyQuantitySum - sellQuantitySum);
decimal netNecessaryAvarage = buyQuantitySum > sellQuantitySum ? buyNecessaryAvarage : sellNecessaryAvarage;
if (shouldUseDayNecessary)
{
netNecessary = _owner.Owner.Setting().RateMarginD *this.GetTradePolicyDetail().MarginD *netQuantity *netNecessaryAvarage;
hedgeNecessary = _owner.Owner.Setting().RateMarginLockD *this.GetTradePolicyDetail().MarginLockedD *hedgeQuantity *(buyNecessaryAvarage + sellNecessaryAvarage);
}
else
{
netNecessary = _owner.Owner.Setting().RateMarginO *this.GetTradePolicyDetail().MarginO *netQuantity *netNecessaryAvarage;
hedgeNecessary = _owner.Owner.Setting().RateMarginLockO *this.GetTradePolicyDetail().MarginLockedO *hedgeQuantity *(buyNecessaryAvarage + sellNecessaryAvarage);
}
}
else if (marginFormula == MarginFormula.FixedAmount || marginFormula == MarginFormula.CS)
{
if (shouldUseDayNecessary)
{
if (marginFormula == 0 && this.GetTradePolicyDetail().VolumeNecessaryId != null)
{
netNecessary = this.GetTradePolicyDetail().VolumeNecessary.CalculateNecessary(_owner.Owner.Setting().RateMarginD, this.GetTradePolicyDetail().MarginD, Math.Abs(buyNecessarySum - sellNecessarySum), true);
}
else
{
netNecessary = _owner.Owner.Setting().RateMarginD *this.GetTradePolicyDetail().MarginD *Math.Abs(buyNecessarySum - sellNecessarySum);
}
hedgeNecessary = _owner.Owner.Setting().RateMarginLockD *this.GetTradePolicyDetail().MarginLockedD *Math.Min(buyNecessarySum, sellNecessarySum);
}
else
{
if (marginFormula == 0 && this.GetTradePolicyDetail().VolumeNecessaryId != null)
{
netNecessary = this.GetTradePolicyDetail().VolumeNecessary.CalculateNecessary(_owner.Owner.Setting().RateMarginO, this.GetTradePolicyDetail().MarginO, Math.Abs(buyNecessarySum - sellNecessarySum), false);
}
else
{
netNecessary = _owner.Owner.Setting().RateMarginO *this.GetTradePolicyDetail().MarginO *Math.Abs(buyNecessarySum - sellNecessarySum);
}
hedgeNecessary = _owner.Owner.Setting().RateMarginLockO *this.GetTradePolicyDetail().MarginLockedO *Math.Min(buyNecessarySum, sellNecessarySum);
}
}
else
{
throw new NotSupportedException(string.Format("Invalid Instrument MarginFormula found, Instrument Id:{0}, MarginFormula{1}", _owner.Id, marginFormula));
}
netNecessary += partialPhysicalNecessarySum;
}
private IEnumerable <InstrumentLotInfo> GetInstrumentLotInfo(Account account, DateTime tradeDay, MarginFormula marginFormula, InstrumentManager instrumentManager)
{
foreach (var eachInstrument in instrumentManager.Instruments)
{
var settingInstrument = Settings.Setting.Default.GetInstrument(eachInstrument.Id, tradeDay);
if (settingInstrument.MarginFormula != marginFormula)
{
continue;
}
if (!eachInstrument.ExistsOrdersForCalculateNormal(tradeDay))
{
continue;
}
InstrumentLotInfo item = new InstrumentLotInfo
{
AccountId = account.Id,
InstrumentId = eachInstrument.Id
};
Debug.Assert(settingInstrument.SpotPaymentTime != null);
bool isSameMonth = (tradeDay.Year - settingInstrument.SpotPaymentTime.Value.Year) * 12 + tradeDay.Month - settingInstrument.SpotPaymentTime.Value.Month == 0;
foreach (var eachOrder in eachInstrument.GetOrders(tradeDay))
{
if (eachOrder.IsForexOrderOrPayoffShortSellOrder())
{
item.CurrentMonthBuy += isSameMonth && eachOrder.Order.IsBuy ? eachOrder.Order.LotBalance : 0m;
item.CurrentMonthSell += isSameMonth && !eachOrder.Order.IsBuy ? eachOrder.Order.LotBalance : 0m;
item.FutureMonthBuy += !isSameMonth && eachOrder.Order.IsBuy ? eachOrder.Order.LotBalance : 0m;
item.FutureMonthSell += !isSameMonth && !eachOrder.Order.IsBuy ? eachOrder.Order.LotBalance : 0m;
}
}
yield return(item);
}
}
private void CalculateMarginResultForInstrumentLotInfoCommon(Dictionary <Guid, MarginResult> marginResultDict, Account account, DateTime tradeDay, MarginFormula marginFormula, Func <Settings.TradePolicyDetail, Settings.CurrencyRate, Settings.Currency, InstrumentLotInfo, decimal> marginFunc, InstrumentManager instrumentManager)
{
var settingAccount = Settings.Setting.Default.GetAccount(account.Id, tradeDay);
foreach (var eachItem in this.GetInstrumentLotInfo(account, tradeDay, marginFormula, instrumentManager))
{
var settingInstrument = Settings.Setting.Default.GetInstrument(eachItem.InstrumentId, tradeDay);
Guid currencyId = settingAccount.IsMultiCurrency ? settingInstrument.CurrencyId : settingAccount.CurrencyId;
var tradePolicyDetail = Settings.Setting.Default.GetTradePolicyDetail(eachItem.InstrumentId, settingAccount.TradePolicyId, tradeDay);
var currencyRate = Settings.Setting.Default.GetCurrencyRate(settingInstrument.CurrencyId, currencyId, tradeDay);
MarginResult marginResult = this.GetMarginResult(account.Id, currencyId, marginResultDict);
var accountCurrency = Settings.Setting.Default.GetCurrency(settingAccount.CurrencyId, tradeDay);
marginResult.Margin += marginFunc(tradePolicyDetail, currencyRate, accountCurrency, eachItem);
}
}
