private void CalculateInstrumentMarginData(Settings.Setting setting, Settings.Account account, Settings.Instrument instrument, DateTime tradeDay, MarginData marginData)
{
var tradePolicyDetail = setting.GetTradePolicyDetail(instrument.Id, account.TradePolicyId, tradeDay);
marginData.Margin += account.RateMarginO * tradePolicyDetail.MarginO;
marginData.MarginLocked += account.RateMarginLockO * tradePolicyDetail.MarginLockedO;
marginData.MarginNight += account.RateMarginO * tradePolicyDetail.MarginO;
marginData.MarginNightLocked += account.RateMarginLockO * tradePolicyDetail.MarginLockedO;
}
private MarginData CreateMarginData(Settings.Setting setting, Settings.Account account, Settings.Instrument instrument, DateTime tradeDay)
{
var tradePolicyDetail = setting.GetTradePolicyDetail(instrument.Id, account.TradePolicyId, tradeDay);
MarginData marginData = new MarginData();
marginData.AccountId = account.Id;
marginData.InstrumentId = instrument.Id;
marginData.CurrencyId = account.IsMultiCurrency ? instrument.CurrencyId : account.CurrencyId;
marginData.MarginFormula = (int)instrument.MarginFormula;
marginData.TradePolicyId = tradePolicyDetail.TradePolicy.ID;
return(marginData);
}
internal static CurrencyRate GetCGSELevyCurrencyRate(Settings.Account account, Settings.Instrument instrument, SpecialTradePolicyDetail specialTradePolicyDetail, CurrencyRate defaultCurrencyRate, ExecuteContext context)
{
if (specialTradePolicyDetail.CGSELevyCurrecyType == CGSELevyCurrecyType.UseInstrumentCurrencyType)
{
return(defaultCurrencyRate);
}
else
{
Guid sourceCurrencyId = account.CurrencyId;
Guid targetCurrencyId = account.IsMultiCurrency ? instrument.CurrencyId : account.CurrencyId;
return(context != null && context.ShouldUseHistorySettings ? Settings.Setting.Default.GetCurrencyRate(sourceCurrencyId, targetCurrencyId, context.TradeDay)
: Settings.Setting.Default.GetCurrencyRate(sourceCurrencyId, targetCurrencyId));
}
}
private bool NeedDoSystemReset(Guid accountId, DateTime tradeDay)
{
Settings.Account historyAccount = Settings.Setting.Default.GetAccount(_account.Id, tradeDay);
if (historyAccount == null)
{
throw new NullReferenceException(string.Format("NeedDoSystemReset historyAccount not exists accountId = {0}, tradeDay = {1}", accountId, tradeDay));
}
bool result = historyAccount.IsActive && historyAccount.MarginInterestOption != Settings.MarginInterestOption.None;
if (result)
{
Logger.InfoFormat("NeedDoSystemReset = {0}, accountId = {1}, tradeDay = {2}, historyAccount.IsActive = {3}, historyAccount.MarginInterestOption = {4}", result,
accountId, tradeDay, historyAccount.IsActive, historyAccount.MarginInterestOption);
}
return(result);
}
internal static decimal CalculateLevy(TradePolicyDetail tradePolicyDetail, SpecialTradePolicyDetail specialTradePolicyDetail,
CurrencyRate currencyRate, Settings.Account account, Settings.Instrument instrument, decimal contractSize, decimal closeLot, Price closePrice)
{
decimal levy = tradePolicyDetail.LevyClose;
if (specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionLevyOn)
{
decimal fractionLevy = specialTradePolicyDetail.LevyClose;
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * levy, (int)closeLot, contractSize, closePrice, currencyRate)
+ FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * fractionLevy, closeLot - (int)closeLot, contractSize, closePrice, currencyRate);
}
else
{
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * levy, closeLot, contractSize, closePrice, currencyRate);
}
return(levy);
}
private void CalculateUsableInterest(DateTime tradeDate)
{
Settings.Account historyAccount = Settings.Setting.Default.GetAccount(_account.Id, tradeDate);
var tradingAccount = TradingSetting.Default.GetAccount(_account.Id);
var usableAmountList = this.CalculateUsableAmount(tradingAccount, historyAccount.MarginInterestOption, tradeDate);
foreach (var eachUsable in usableAmountList)
{
Guid currencyId = eachUsable.Key;
decimal usableAmount = eachUsable.Value;
var currency = Settings.Setting.Default.GetCurrency(currencyId);
if (currency.InterestPolicyId == null)
{
continue;
}
var interestPolicy = Settings.Setting.Default.GetInterestPolicy(currency.InterestPolicyId.Value);
var interestRate = usableAmount > 0 ? currency.UInterestIn : currency.UInterestOut;
var interest = usableAmount * interestRate / currency.UsableInterestDayYear;
decimal usableInterest = interest * this.GetInterestMultiple(tradeDate, interestPolicy);
var tradeDay = Settings.Setting.Default.GetTradeDay(tradeDate);
_account.AddBalance(currencyId, usableInterest, tradeDay.EndTime);
}
}
internal static void CalculateFee(TradePolicyDetail tradePolicyDetail, SpecialTradePolicyDetail specialTradePolicyDetail,
CurrencyRate currencyRate, DateTime tradeDayBeginTime, Settings.Account account, Settings.Instrument instrument,
decimal contractSize, decimal pairRelationFactor, DateTime openOrderExecuteTime, decimal closedLot, Price executePrice,
out decimal commission, out decimal levy)
{
bool isDayCloseRelation = openOrderExecuteTime >= tradeDayBeginTime;
commission = pairRelationFactor * tradePolicyDetail.GetCommissionClose(isDayCloseRelation);
levy = tradePolicyDetail.LevyClose;
if (specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn)
{
decimal fractionCommission = pairRelationFactor * specialTradePolicyDetail.GetCommissionClose(isDayCloseRelation);
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * commission, (int)closedLot, contractSize, executePrice, currencyRate)
+ FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * fractionCommission, closedLot - (int)closedLot, contractSize, executePrice, currencyRate);
}
else
{
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * commission, closedLot, contractSize, executePrice, currencyRate);
}
if (specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionLevyOn)
{
decimal fractionLevy = specialTradePolicyDetail.LevyClose;
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * levy, (int)closedLot, contractSize, executePrice, currencyRate)
+ FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * fractionLevy, closedLot - (int)closedLot, contractSize, executePrice, currencyRate);
}
else
{
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * levy, closedLot, contractSize, executePrice, currencyRate);
}
}
internal static decimal CalculateCommission(TradePolicyDetail tradePolicyDetail, SpecialTradePolicyDetail specialTradePolicyDetail,
CurrencyRate currencyRate, DateTime tradeDayBeginTime, Settings.Account account, Settings.Instrument instrument,
decimal contractSize, decimal pairRelationFactor, DateTime openOrderExecuteTime, decimal closeLot, Price closePrice)
{
bool isDayCloseRelation = openOrderExecuteTime >= tradeDayBeginTime;
decimal commission = pairRelationFactor * tradePolicyDetail.GetCommissionClose(isDayCloseRelation);
if (specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn)
{
decimal fractionCommission = pairRelationFactor * specialTradePolicyDetail.GetCommissionClose(isDayCloseRelation);
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * commission, (int)closeLot, contractSize, closePrice, currencyRate)
+ FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * fractionCommission, closeLot - (int)closeLot, contractSize, closePrice, currencyRate);
}
else
{
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * commission, closeLot, contractSize, closePrice, currencyRate);
}
return(commission);
}
protected abstract bool ShouldCalculateLockOrderTradePLFloat(Settings.Account account, decimal buyQuantitySum, decimal sellQuantitySum);
protected override bool ShouldCalculateLockOrderTradePLFloat(Settings.Account account, decimal buyQuantitySum, decimal sellQuantitySum)
{
return(buyQuantitySum != sellQuantitySum && account.IsAutoCut && account.RiskLevelAction == RiskLevelAction.HedgeExact);
}
protected override bool ShouldCalculateLockOrderTradePLFloat(Settings.Account account, decimal buyQuantitySum, decimal sellQuantitySum)
{
return(false);
}
private decimal InnerCalculate()
{
decimal buyLotSum = 0, sellLotSum = 0;
List <Order> openBuyOrders = null, openSellOrders = null;
List <CuttingItem> openBuyItems = null, openSellItems = null;
Settings.Account account = this._owner.Owner.Setting();
if (account.RiskLevelAction == RiskLevelAction.CloseAll)
{
openBuyItems = new List <CuttingItem>();
openSellItems = new List <CuttingItem>();
}
else
{
openBuyOrders = new List <Order>();
openSellOrders = new List <Order>();
}
List <Order> orders = new List <Order>(this._owner.ExecutedAndHasPositionOrders);
orders.Sort(AutoCloseOrderComparer.Default);
foreach (Order eachOrder in orders)
{
if (!eachOrder.IsRisky)
{
continue;
}
if (eachOrder.Phase == OrderPhase.Executed && eachOrder.LotBalance > 0)
{
if (eachOrder.IsBuy)
{
buyLotSum += eachOrder.LotBalance;
if (openBuyOrders != null)
{
openBuyOrders.Add(eachOrder);
}
else
{
openBuyItems.Add(new CuttingItem(eachOrder.IsBuy, eachOrder.Owner.ContractSize(null), eachOrder.LotBalance, eachOrder.Owner.ExecuteTime.Value, eachOrder.ExecutePrice));
}
}
else
{
sellLotSum += eachOrder.LotBalance;
if (openSellOrders != null)
{
openSellOrders.Add(eachOrder);
}
else
{
openSellItems.Add(new CuttingItem(eachOrder.IsBuy, eachOrder.Owner.ContractSize(null), eachOrder.LotBalance, eachOrder.Owner.ExecuteTime.Value, eachOrder.ExecutePrice));
}
}
}
}
if (account.RiskLevelAction == RiskLevelAction.CloseAll)
{
return(this.CaculateFeeForCuttingAll(buyLotSum, openBuyItems, sellLotSum, openSellItems));
}
else
{
return(this.CaculateFeeForCuttingNet(buyLotSum, openBuyOrders, sellLotSum, openSellOrders));
}
}
private decimal CaculateFeeForCutting(decimal closedLot, Price cutPrice, ICollection <CuttingItem> cuttingItems)
{
if ((decimal)cutPrice == 0)
{
return(0m);
}
decimal commission = 0m, levy = 0m, otherFee = 0m;
Settings.Instrument instrument = _owner.Setting;
Settings.Account account = _owner.Owner.Setting();
TradePolicyDetail tradePolicyDetail = _owner.TradePolicyDetail();
SpecialTradePolicyDetail specialTradePolicyDetail = _owner.SpecialTradePolicyDetail(null);
decimal contractSize = tradePolicyDetail.ContractSize;
CurrencyRate currencyRate = _owner.CurrencyRate(null);
if (instrument.ExchangeSystem == ExchangeSystem.Local &&
(account.RiskLevelAction == RiskLevelAction.CloseNetPosition || account.RiskLevelAction == RiskLevelAction.CloseAll))
{
if (!instrument.CommissionFormula.TakeFeeAsCost() || !instrument.LevyFormula.TakeFeeAsCost() || !instrument.OtherFeeFormula.TakeFeeAsCost())
{
foreach (CuttingItem eachCuttingItem in cuttingItems)
{
Price buyPrice, sellPrice, closePrice;
if (eachCuttingItem.IsBuy)
{
buyPrice = cutPrice;
sellPrice = eachCuttingItem.ExecutePrice;
}
else
{
sellPrice = cutPrice;
buyPrice = eachCuttingItem.ExecutePrice;
}
closePrice = cutPrice;
decimal subCommission = 0m, subLevy = 0m, subOtherFee = 0m;
decimal tradePL = TradePLCalculator.Calculate(instrument.TradePLFormula, eachCuttingItem.CuttingLot, eachCuttingItem.ContractSize, (decimal)buyPrice, (decimal)sellPrice, (decimal)closePrice, _owner.Currency(null).Decimals);
var feeParameter = new FeeParameter()
{
Account = account,
TradePolicyDetail = tradePolicyDetail,
SpecialTradePolicyDetail = specialTradePolicyDetail,
Instrument = instrument,
CurrencyRate = currencyRate,
ContractSize = contractSize,
OpenOrderExecuteTime = eachCuttingItem.ExecuteTime,
ClosedLot = eachCuttingItem.CuttingLot,
ExecutePrice = cutPrice,
TradePL = tradePL
};
OrderRelation.CalculateFee(feeParameter, out subCommission, out subLevy, out subOtherFee);
commission += subCommission;
levy += subLevy;
otherFee += subOtherFee;
}
}
if (instrument.LevyFormula.TakeFeeAsCost())
{
levy = this.CalculateFeeCommon(account.RateLevy, tradePolicyDetail.LevyClose, closedLot, contractSize);
}
if (instrument.OtherFeeFormula.TakeFeeAsCost())
{
otherFee = this.CalculateFeeCommon(account.RateOtherFee, tradePolicyDetail.OtherFeeClose, closedLot, contractSize);
}
if (instrument.CommissionFormula.TakeFeeAsCost())
{
commission = this.CalculateFeeCommon(account.RateCommission, tradePolicyDetail.CommissionCloseD, closedLot, contractSize);
}
else
{
if (commission >= 0)
{
commission = Math.Max(commission, tradePolicyDetail.MinCommissionClose);
}
}
}
else
{
if (instrument.CommissionFormula.TakeFeeAsCost()) //Adjust PricePips
{
commission = this.CalculateFeeCommon(account.RateCommission, tradePolicyDetail.CommissionOpen, closedLot, contractSize);
}
else
{
if (!instrument.CommissionFormula.IsDependOnPL() && specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn)
{
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen,
(int)closedLot, contractSize, cutPrice, currencyRate) +
FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen, closedLot - (int)closedLot,
contractSize, cutPrice, currencyRate);
}
else
{
commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen, closedLot, contractSize, cutPrice, currencyRate);
}
if (commission >= 0)
{
commission = Math.Max(commission, tradePolicyDetail.MinCommissionOpen);
}
}
if (instrument.LevyFormula.TakeFeeAsCost()) //Adjust PricePips
{
levy = this.CalculateFeeCommon(account.RateLevy, tradePolicyDetail.LevyOpen, closedLot, contractSize);
}
else
{
if (!instrument.LevyFormula.IsDependOnPL() && specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn)
{
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, (int)closedLot
, contractSize, cutPrice, currencyRate) +
FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, closedLot - (int)closedLot
, contractSize, cutPrice, currencyRate);
}
else
{
levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, closedLot, contractSize, cutPrice, currencyRate);
}
if (!instrument.LevyFormula.IsDependOnPL() && specialTradePolicyDetail != null)
{
CurrencyRate cgseLevyCurrencyRate = FeeCalculator.GetCGSELevyCurrencyRate(account, instrument, specialTradePolicyDetail, currencyRate, null);
levy += FeeCalculator.CalculateCGSELevy(closedLot, true, specialTradePolicyDetail, cgseLevyCurrencyRate);
}
}
if (instrument.OtherFeeFormula.TakeFeeAsCost())
{
otherFee = this.CalculateFeeCommon(account.RateOtherFee, tradePolicyDetail.OtherFeeOpen, closedLot, contractSize);
}
else
{
otherFee = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateOtherFee * tradePolicyDetail.OtherFeeOpen, closedLot, contractSize, cutPrice, currencyRate);
}
}
return(commission + levy + otherFee);;
}
private decimal CalculateOrderMargin(Order order, Settings.Setting setting, Settings.Instrument instrument, Settings.Account account, DateTime tradeDay, UsableMarginPrice usableMarginPrice)
{
Guid currencyId = this.GetCurrencyId(account, instrument);
var currencyRate = setting.GetCurrencyRate(instrument.CurrencyId, currencyId);
decimal?rateIn = currencyRate == null ? (decimal?)null : currencyRate.RateIn;
decimal?rateOut = currencyRate == null ? (decimal?)null : currencyRate.RateOut;
var currency = setting.GetCurrency(currencyId, tradeDay);
int decimals = currency.Decimals;
Price refPrice = this.GetRefPrice(usableMarginPrice, order.IsBuy, instrument.IsNormal);
return(Calculator.MarginCalculator.CalculateRptMargin((int)instrument.MarginFormula, order.LotBalance, order.Owner.ContractSize(tradeDay), order.ExecutePrice, rateIn, rateOut, decimals, refPrice));
}
private Guid GetCurrencyId(Settings.Account account, Settings.Instrument instrument)
{
return(account.IsMultiCurrency ? instrument.CurrencyId : account.CurrencyId);
}
