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);
}
}
private void CalculateMinEquitities(decimal netNecessary, decimal hedgeNecessary, DateTime baseTime, int decimals)
{
TradePolicyDetail tradePolicyDetail = this.GetTradePolicyDetail();
bool useNightNecessaryWhenBreak = Settings.Setting.Default.SystemParameter.UseNightNecessaryWhenBreak;
DateTime tradeDayBeginTime = Settings.Setting.Default.SystemParameter.TradeDayBeginTime;
bool useAlertLevel4 = this.ShouldUseAlertLevel4(baseTime, useNightNecessaryWhenBreak, tradeDayBeginTime);
decimal alertLevel3 = useAlertLevel4 && tradePolicyDetail.AlertLevel4 > 0 ? tradePolicyDetail.AlertLevel4 : tradePolicyDetail.AlertLevel3;
decimal alertLevel3Lock = useAlertLevel4 && tradePolicyDetail.AlertLevel4Lock > 0 ? tradePolicyDetail.AlertLevel4Lock : tradePolicyDetail.AlertLevel3Lock;
_riskData.MinEquityAvoidRiskLevel1 = this.CalculateMinEquity(netNecessary, hedgeNecessary, decimals, tradePolicyDetail.AlertLevel1, tradePolicyDetail.AlertLevel1Lock);
_riskData.MinEquityAvoidRiskLevel2 = this.CalculateMinEquity(netNecessary, hedgeNecessary, decimals, tradePolicyDetail.AlertLevel2, tradePolicyDetail.AlertLevel2Lock);
_riskData.MinEquityAvoidRiskLevel3 = this.CalculateMinEquity(netNecessary, hedgeNecessary, decimals, tradePolicyDetail.AlertLevel3, tradePolicyDetail.AlertLevel3Lock);
}
internal static decimal CalculatePreCheckNecessary(this Instrument instrument, Transaction tran)
{
Account account = tran.Owner;
TradePolicyDetail tradePolicyDetail = instrument.TradePolicyDetail;
int decimals = Math.Min(instrument.Currency.Decimals, tradePolicyDetail.NecessaryRound);
if (tran.TradingInstrument == instrument)
{
return(InnerCalculatePreCheckNecessary(instrument, tran, tran.FirstOrder.IsBuy));
}
decimal buyPreCheckNecessary = InnerCalculatePreCheckNecessary(instrument, tran, true);
decimal sellPreCheckNecessary = InnerCalculatePreCheckNecessary(instrument, tran, false);
return(Math.Max(buyPreCheckNecessary, sellPreCheckNecessary));
}
internal static bool IsExceedMaxOpenLot(Transaction tran, PlaceContext context, out string errorInfo)
{
errorInfo = string.Empty;
if (!tran.ShouldCheckIsExceedMaxOpenLot)
{
return(false);
}
TradePolicyDetail tradePolicyDetail = tran.TradePolicyDetail(context.TradeDay);
var settingAccount = tran.Owner.Setting(context.TradeDay);
if (settingAccount.MaxOpenLot == null && tradePolicyDetail.AccountMaxOpenLot == null)
{
return(false);
}
if (!tran.ExistsOpenOrder())
{
return(false);
}
bool isBuy = tran.FirstOrder.IsBuy;
var placingLotsPerInstrument = CalculateBuySellInfoPerInstrument(tran.Owner.Transactions);
decimal totalPlacingOpenLot = 0, totalPlacingOpenLotOfTheInstrument = 0;
foreach (Guid instrumentId in placingLotsPerInstrument.Keys)
{
BuySellLot info = placingLotsPerInstrument[instrumentId];
if (instrumentId == tran.InstrumentId)
{
totalPlacingOpenLotOfTheInstrument = isBuy ? info.BuyLot : info.SellLot;
totalPlacingOpenLot += (isBuy ? info.BuyLot : info.SellLot);
}
else
{
totalPlacingOpenLot += Math.Max(info.BuyLot, info.SellLot);
}
}
decimal?accountMaxOpenLot = settingAccount.MaxOpenLot;
if ((accountMaxOpenLot != null && totalPlacingOpenLot > accountMaxOpenLot) ||
(tradePolicyDetail.AccountMaxOpenLot != null && totalPlacingOpenLotOfTheInstrument > tradePolicyDetail.AccountMaxOpenLot))
{
errorInfo = string.Format("totalPlacingOpenLot={0}, totalPlacingOpenLotOfTheInstrument={1}, account.MaxOpenLot={2}, tradePolicyDetail.AccountMaxOpenLot={3}, tranID = {4}, accountID = {5}",
totalPlacingOpenLot, totalPlacingOpenLotOfTheInstrument, accountMaxOpenLot, tradePolicyDetail.AccountMaxOpenLot, tran.Id, tran.AccountId);
return(true);
}
return(false);
}
private static decimal InnerCalculatePreCheckNecessary(Instrument instrument, Transaction tran, bool isBuy)
{
TradePolicyDetail tradePolicyDetail = instrument.TradePolicyDetail;
MarginAndQuantityResult unfilledArgs = new MarginAndQuantityResult();
Dictionary <Guid, decimal> remainFilledLotPerOrderDict = null;
if (tran.IsPending)
{
unfilledArgs = UnfilledCalculator.Default.CalculateUnfilledMarginArgsForPlacePendingOrder(instrument, tran, isBuy, out remainFilledLotPerOrderDict);
}
MarginAndQuantityResult filledArgs = new MarginAndQuantityResult();
MarginAndQuantityResult marginArgs = new MarginAndQuantityResult();
instrument.InitializeFilledAndMarginArgs(isBuy, unfilledArgs, filledArgs, marginArgs);
filledArgs += FilledCalculator.Default.CalculateFillMarginAndQuantity(instrument, isBuy, remainFilledLotPerOrderDict);
return(CalculateNecessary(instrument, isBuy, marginArgs, filledArgs));
}
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);
}
internal static decimal CalculatePreCheckBalance(this Instrument instrument)
{
if (!instrument.IsPhysical)
{
return(0);
}
Price buy = null;
Account account = instrument.Owner;
Quotation quotation = QuotationProvider.GetLatestQuotation(instrument.Id, account);
Debug.Assert(quotation != null);
buy = quotation.BuyOnCustomerSide;
decimal preCheckBalance = 0m;
TradePolicyDetail tradePolicyDetail = instrument.TradePolicyDetail;
foreach (Transaction tran in account.GetTransactions(instrument.Id))
{
foreach (PhysicalOrder order in tran.Orders)
{
if (order.PhysicalTradeSide == PhysicalTradeSide.Buy && order.IsOpen)
{
if (order.Phase == OrderPhase.Placed || order.Phase == OrderPhase.Placing)
{
var price = order.SetPrice == null ? buy : order.SetPrice;
decimal marketValue = MarketValueCalculator.CalculateValue(instrument.Setting.TradePLFormula, order.Lot, price,
tradePolicyDetail.DiscountOfOdd, tradePolicyDetail.ContractSize);
if (order.IsInstalment)
{
decimal instalmentAdministrationFee = order.CalculateInstalmentAdministrationFee(marketValue);
decimal downPayment = order.CalculatePaidAmount(marketValue);
preCheckBalance += (instalmentAdministrationFee + downPayment);
}
else
{
preCheckBalance += marketValue;
}
}
}
}
}
return(preCheckBalance);
}
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);
}
private static void Initialize(TradePolicyDetail tradePolicyDetail, DataRow dataRow)
{
tradePolicyDetail.TradePolicyId = (Guid)dataRow["TradePolicyID"];
tradePolicyDetail.InstrumentId = (Guid)dataRow["InstrumentID"];
tradePolicyDetail.ContractSize = (decimal)dataRow["ContractSize"];
tradePolicyDetail.IsTradeActive = (bool)dataRow["IsTradeActive"];
tradePolicyDetail.CommissionCloseD = dataRow.GetItemValue <decimal>("CommissionCloseD", 0);
tradePolicyDetail.CommissionCloseO = dataRow.GetItemValue <decimal>("CommissionCloseO", 0);
tradePolicyDetail.MinCommissionClose = dataRow.GetItemValue <decimal>("MinCommissionClose", 0);
tradePolicyDetail.MinCommissionOpen = dataRow.GetItemValue <decimal>("MinCommissionOpen", 0);
tradePolicyDetail.MinOpen = dataRow.GetItemValue <decimal>("MinOpen", 0);
tradePolicyDetail.OpenMultiplier = dataRow.GetItemValue <decimal>("OpenMultiplier", 0);
tradePolicyDetail.MinClose = dataRow.GetItemValue <decimal>("MinClose", 0);
tradePolicyDetail.DefaultLot = dataRow.GetItemValue <decimal>("DefaultLot", 0);
tradePolicyDetail.CloseMultiplier = dataRow.GetItemValue <decimal>("CloseMultiplier", 0);
tradePolicyDetail.Option = (int)dataRow["Option"];
tradePolicyDetail.IsAcceptNewStop = (bool)dataRow["IsAcceptNewStop"];
tradePolicyDetail.IsAcceptNewLimit = (bool)dataRow["IsAcceptNewLimit"];
tradePolicyDetail.IsAcceptNewMOOMOC = (bool)dataRow["IsAcceptNewMOOMOC"];
tradePolicyDetail.MultipleCloseAllowed = (bool)dataRow["MultipleCloseAllowed"];
tradePolicyDetail.AllowIfDone = (bool)dataRow["AllowIfDone"];
tradePolicyDetail.AllowNewOCO = (bool)dataRow["AllowNewOCO"];
tradePolicyDetail.InterestRateId = dataRow.GetItemValue <Guid?>("InterestRateID", null);
tradePolicyDetail.InterestRateBuy = dataRow.GetItemValue <decimal?>("InterestRateBuy", null);
tradePolicyDetail.InterestRateSell = dataRow.GetItemValue <decimal?>("InterestRateSell", null);
tradePolicyDetail.DQMaxMove = (int)dataRow["DQMaxMove"];
tradePolicyDetail.PairRelationFactor = dataRow.GetItemValue <decimal?>("PairRelationFactor", null);
tradePolicyDetail.GoodTillDate = (bool)dataRow["GoodTillDate"];
tradePolicyDetail.GoodTillMonthDayOrder = (bool)dataRow["GoodTillMonthDayOrder"];
tradePolicyDetail.GoodTillMonthSession = (bool)dataRow["GoodTillMonthSession"];
tradePolicyDetail.GoodTillMonthGTM = (bool)dataRow["GoodTillMonthGTM"];
tradePolicyDetail.GoodTillMonthGTF = (bool)dataRow["GoodTillMonthGTF"];
tradePolicyDetail.CanPlaceMatchOrder = (bool)dataRow["CanPlaceMatchOrder"];
tradePolicyDetail.ChangePlacedOrderAllowed = dataRow.Table.Columns.Contains("ChangePlacedOrderAllowed") ? (bool)dataRow["ChangePlacedOrderAllowed"] : false;
tradePolicyDetail.MarginD = (decimal)dataRow["MarginD"];
tradePolicyDetail.MarginO = (decimal)dataRow["MarginO"];
tradePolicyDetail.MarginLockedD = (decimal)dataRow["MarginLockedD"];
tradePolicyDetail.MarginLockedO = (decimal)dataRow["MarginLockedO"];
tradePolicyDetail.NecessaryRound = (int)dataRow["NecessaryRound"];
if (dataRow.Table.Columns.Contains("VolumeNecessaryId"))
{
tradePolicyDetail.VolumeNecessaryId = dataRow.GetItemValue <Guid?>("VolumeNecessaryId", null);
}
tradePolicyDetail.AllowedPhysicalTradeSides = (int)dataRow["AllowedPhysicalTradeSides"];
tradePolicyDetail.DiscountOfOdd = (decimal)dataRow["DiscountOfOdd"];
tradePolicyDetail.ValueDiscountAsMargin = (decimal)dataRow["ValueDiscountAsMargin"];
tradePolicyDetail.PhysicalMinDeliveryQuantity = (decimal)dataRow["PhysicalMinDeliveryQuantity"];
tradePolicyDetail.PhysicalDeliveryIncremental = (decimal)dataRow["PhysicalDeliveryIncremental"];
if (dataRow.Table.Columns.Contains("DeliveryChargeId"))
{
tradePolicyDetail.DeliveryChargeId = dataRow.GetItemValue <Guid?>("DeliveryChargeId", null);
}
if (dataRow.Table.Columns.Contains("InstalmentPolicyId"))
{
tradePolicyDetail.InstalmentPolicyId = dataRow.GetItemValue <Guid?>("InstalmentPolicyId", null);
}
if (dataRow.Table.Columns.Contains("PartPaidPhysicalNecessary"))
{
tradePolicyDetail.PartPaidPhysicalNecessary = dataRow.GetItemValue <decimal?>("PartPaidPhysicalNecessary", null);
}
}
private static SettingSet ToSettingSet(XmlNode content)
{
SettingSet settingSet = new SettingSet();
List<Instrument> instruments = null;
List<Customer> customers = null;
List<TradePolicyDetail> tradePolicyDetails = null;
List<QuotePolicyDetail> quotePolicyDetails = null;
foreach (XmlNode xmlNode in content.ChildNodes)
{
string name = xmlNode.Name;
if (name == "PrivateDailyQuotation")
{
settingSet.PrivateDailyQuotation = new PrivateDailyQuotation();
settingSet.PrivateDailyQuotation.Initialize(xmlNode);
}
else if (name == "SystemParameter")
{
settingSet.SystemParameter = new SystemParameter();
settingSet.SystemParameter.Initialize(xmlNode);
}
else if (name == "Instruments")
{
foreach (XmlNode instrumentNode in xmlNode.ChildNodes)
{
Instrument instrument = new Instrument();
instrument.Initialize(instrumentNode);
if (instruments == null) instruments = new List<Instrument>();
instruments.Add(instrument);
}
}
else if (name == "Instrument")
{
Instrument instrument = new Instrument();
instrument.Initialize(xmlNode);
if (instruments == null) instruments = new List<Instrument>();
instruments.Add(instrument);
}
else if (name == "Account")
{
Account account = new Account();
account.Initialize(xmlNode);
settingSet.Accounts = new Account[] { account };
}
else if (name == "Customers")
{
foreach (XmlNode customerNode in xmlNode.ChildNodes)
{
Customer customer = new Customer();
customer.Initialize(customerNode);
if (customers == null) customers = new List<Customer>();
customers.Add(customer);
}
}
else if (name == "TradePolicyDetail")
{
TradePolicyDetail tradePolicyDetail = new TradePolicyDetail();
tradePolicyDetail.Initialize(xmlNode);
if (tradePolicyDetails == null) tradePolicyDetails = new List<TradePolicyDetail>();
tradePolicyDetails.Add(tradePolicyDetail);
}
else if (name == "QuotePolicyDetail")
{
QuotePolicyDetail quotePolicyDetail = new QuotePolicyDetail();
quotePolicyDetail.Initialize(xmlNode);
if (quotePolicyDetails == null) quotePolicyDetails = new List<QuotePolicyDetail>();
quotePolicyDetails.Add(quotePolicyDetail);
}
else if (name == "QuotePolicyDetails")
{
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
QuotePolicyDetail quotePolicyDetail = new QuotePolicyDetail();
quotePolicyDetail.Initialize(childNode);
if (quotePolicyDetails == null) quotePolicyDetails = new List<QuotePolicyDetail>();
quotePolicyDetails.Add(quotePolicyDetail);
}
}
}
settingSet.Instruments = (instruments.IsNullOrEmpty() ? null : instruments.ToArray());
settingSet.Customers = (customers.IsNullOrEmpty() ? null : customers.ToArray());
settingSet.TradePolicyDetails = (tradePolicyDetails.IsNullOrEmpty() ? null : tradePolicyDetails.ToArray());
settingSet.QuotePolicyDetails = (quotePolicyDetails.IsNullOrEmpty() ? null : quotePolicyDetails.ToArray());
return settingSet;
}
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);;
}
