internal List <OrderRelation> UpdateOrderRelationValueDate(TradeDayInfo info)
{
List <OrderRelation> result = new List <OrderRelation>();
if (info.Settings.ValueDate == null)
{
return(result);
}
foreach (var eachOrderRelation in info.OrderRelations)
{
if (!this.ShouldUpdateOrderRelationValueDate(eachOrderRelation, info.Settings.ResetTime))
{
continue;
}
var instrumentDayOpenCloseHistory = ResetManager.Default.GetInstrumentDayOpenCloseHistory(info.Instrument.Id, eachOrderRelation.CloseOrder.ExecuteTime.Value.Date);
if (instrumentDayOpenCloseHistory.RealValueDate == info.TradeDay)
{
result.Add(eachOrderRelation);
eachOrderRelation.ValueTime = info.Settings.ResetTime;
eachOrderRelation.RateIn = info.RateSetting.RateIn;
eachOrderRelation.RateOut = info.RateSetting.RateOut;
eachOrderRelation.Decimals = info.RateSetting.RoundDecimals.Common;
}
}
return(result);
}
private static bool IsOpenOrderOfCurrentDay(Order order, TradeDayInfo tradeDayInfo)
{
var tradePolicyDetail = Settings.Setting.Default.GetTradePolicy(tradeDayInfo.Account.TradePolicyId, tradeDayInfo.TradeDay)[tradeDayInfo.Instrument.Id, null];
return(order.IsOpen && (tradePolicyDetail.InterestCut == tradeDayInfo.Settings.WeekDay || tradePolicyDetail.InterestCut == 11 ||
(tradePolicyDetail.InterestCut == 12 && tradeDayInfo.Settings.IsMonthLastDay)));
}
private static TradeDayCalculator CreateCommon(TradeDayInfo tradeDayInfo, InstrumentCloseQuotation closeQuotation, bool isReset)
{
if (closeQuotation != null)
{
tradeDayInfo.UpdateInstrumentDayClosePrice(closeQuotation.BuyPrice, closeQuotation.SellPrice);
}
return(new TradeDayCalculator(tradeDayInfo, isReset));
}
internal TradeDayCalculator(TradeDayInfo data, bool isReset)
{
_info = data;
_isReset = isReset;
_orderPhaseUpdater = new OrderPhaseUpdater(data.CloseOrders, _info.Settings.ResetTime, _info.Instrument.Id, _info.TradeDay);
this.Balance = 0m;
_exchanger = new Exchanger(data.RateSetting);
}
private void DoResetPerTradeDay(AccountClass.Instrument instrument, TradeDayInfo eachResetHistorySetting, InstrumentCloseQuotation closeQuotation)
{
var settingInstrument = Settings.Setting.Default.GetInstrument(instrument.Id, eachResetHistorySetting.TradeDay);
var calculator = TradeDayCalculatorFactory.CreateForReset(eachResetHistorySetting, closeQuotation, Settings.Setting.Default);
calculator.Calculate();
_account.AddBalance(settingInstrument.CurrencyId, calculator.Balance, calculator.ResetTime);
OrderDayHistorySaver.Save(_account, instrument, calculator, eachResetHistorySetting, settingInstrument);
}
private static OrderResetResult CreateOrderResetResult(Order closeOrder, TradeDayInfo tradeDayInfo, Dictionary <Guid, OrderResetResult> resetOrderDict)
{
OrderResetResult resetResult;
if (!resetOrderDict.TryGetValue(closeOrder.Id, out resetResult))
{
resetResult = new OrderResetResult();
CalculateOrderRelationPLCommon(closeOrder, resetResult, tradeDayInfo);
resetOrderDict.Add(closeOrder.Id, resetResult);
}
return(resetResult);
}
private static TradeDayInfo LoadHistoryDataPerTradeDay(this Account account, Guid instrumentId, DateTime tradeDay)
{
var instrumentTradeDaySetting = ResetManager.Default.LoadInstrumentHistorySettingAndData(account.Id, instrumentId, tradeDay);
if (instrumentTradeDaySetting == null)
{
return(null);
}
var data = new TradeDayInfo(account, instrumentId, tradeDay, instrumentTradeDaySetting, null, Settings.Setting.Default);
return(data);
}
private decimal RecoverOrderDayHistory(DateTime tradeDay, List <Guid> affectedOrders)
{
var settingInstrument = _setting.GetInstrument(_instrumentId, tradeDay);
var instrumentTradeDaySetting = ResetManager.Default.LoadInstrumentHistorySettingAndData(_account.Id, _instrumentId, tradeDay);
TradeDayInfo tradeDayInfo = new TradeDayInfo(_account, _instrumentId, tradeDay, instrumentTradeDaySetting, affectedOrders, _setting);
var closeQuotation = _InstrumentDayClosePriceFactory.GetQuotation(settingInstrument, tradeDay);
TradeDayCalculator tradeDayCalculator = TradeDayCalculatorFactory.CreateForHistoryOrder(tradeDayInfo, closeQuotation);
tradeDayCalculator.Calculate();
var resetResults = tradeDayCalculator.ResetResults;
if (resetResults == null)
{
return(0m);
}
OrderDayHistorySaver.Save(_account, _account.GetInstrument(_instrumentId), tradeDayCalculator, tradeDayInfo, settingInstrument);
return(tradeDayCalculator.ValuedPLForBook);
}
internal static Dictionary <Guid, OpenOrderPLOfCurrentDay> Calculate(TradeDayInfo tradeDayInfo, Dictionary <Guid, TradeDayCommonResult> resetCommonResultDict, Exchanger exchanger)
{
if (tradeDayInfo.Settings.ValueDate == null && !tradeDayInfo.Settings.UseCompatibleMode)
{
return(null);
}
Dictionary <Guid, OpenOrderPLOfCurrentDay> result = new Dictionary <Guid, OpenOrderPLOfCurrentDay>();
foreach (var eachPair in resetCommonResultDict)
{
var orderId = eachPair.Key;
var commonResetResult = eachPair.Value;
if (!orderId.ShouldCalculate(tradeDayInfo.AffectedOrders))
{
continue;
}
var eachOrder = tradeDayInfo.GetOrder(orderId);
if (!IsOpenOrderOfCurrentDay(eachOrder, tradeDayInfo))
{
continue;
}
OpenOrderPLOfCurrentDay openOrderPLOfCurrentDay = new OpenOrderPLOfCurrentDay();
int decimals = tradeDayInfo.Settings.IsInterestUseAccountCurrency ? tradeDayInfo.RateSetting.RoundDecimals.Max : tradeDayInfo.RateSetting.RoundDecimals.Instrument;
var storage = Math.Round(eachOrder.LotBalance * commonResetResult.StoragePerLot, decimals, MidpointRounding.AwayFromZero);
var interest = Math.Round(eachOrder.LotBalance * commonResetResult.InterestPerLot, decimals, MidpointRounding.AwayFromZero);
openOrderPLOfCurrentDay.DayNotValued += tradeDayInfo.Settings.ShouldValueCurrentDayPL ? InterestStorage.Empty : new InterestStorage(interest, storage);
var exchangeStorage = exchanger.ExchangeByCommonDecimals(storage);
var exchangeInterest = exchanger.ExchangeByCommonDecimals(interest);
openOrderPLOfCurrentDay.NotValued += tradeDayInfo.Settings.ShouldValueCurrentDayPL ? InterestStorage.Empty : new InterestStorage(exchangeInterest, exchangeStorage);
bool isInterestValued = (eachOrder.InterestValueDate ?? tradeDayInfo.TradeDay) <= tradeDayInfo.TradeDay;
decimal interestPLValued = tradeDayInfo.Settings.ShouldValueCurrentDayPL && isInterestValued ? exchangeInterest : 0;
decimal storagePLValued = tradeDayInfo.Settings.ShouldValueCurrentDayPL ? exchangeStorage : 0;
openOrderPLOfCurrentDay.Valued += new InterestStorage(interestPLValued, storagePLValued);
openOrderPLOfCurrentDay.IsInterestValued = isInterestValued;
openOrderPLOfCurrentDay.IsStorageValued = true;
result.Add(orderId, openOrderPLOfCurrentDay);
}
return(result);
}
private static void CalculateValuedOrderRelationPL(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
foreach (var eachOrderRelation in tradeDayInfo.OrderRelations)
{
Order closeOrder = eachOrderRelation.CloseOrder;
if (!closeOrder.ShouldCalculate(affectedOrders))
{
continue;
}
if (closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= tradeDayInfo.Settings.ResetTime && eachOrderRelation.ValueTime > tradeDayInfo.Settings.BeginTime && eachOrderRelation.ValueTime <= tradeDayInfo.Settings.ResetTime)
{
var resetResult = CreateOrderResetResult(closeOrder, tradeDayInfo, resetOrderDict);
var valuedPL = eachOrderRelation.CalculateValuedPL();
resetResult.ValuedPL += new InterestStorage(valuedPL.InterestPL, valuedPL.StoragePL);
resetResult.TradePLValued += valuedPL.TradePL;
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (physicalOrderRelation != null)
{
resetResult.PhysicalTradePLValued += CalculatePhysicalTradePL(physicalOrderRelation, exchanger);
}
}
}
}
private static void CalculateNotValuedOrderRelationPL(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
foreach (var eachOrderRelation in tradeDayInfo.OrderRelations)
{
Order closeOrder = eachOrderRelation.CloseOrder;
if (!closeOrder.ShouldCalculate(affectedOrders))
{
continue;
}
PhysicalOrder physicalCloseOrder = closeOrder as PhysicalOrder;
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= tradeDayInfo.Settings.ResetTime && eachOrderRelation.ValueTime == null)
{
OrderResetResult resetResult = CreateOrderResetResult(closeOrder, tradeDayInfo, resetOrderDict);
resetResult.NotValuedPL += new InterestStorage(exchanger.ExchangeByCommonDecimals(eachOrderRelation.InterestPL), exchanger.ExchangeByCommonDecimals(eachOrderRelation.StoragePL));
resetResult.TradePLNotValued += exchanger.ExchangeByCommonDecimals(eachOrderRelation.TradePL);
if (physicalOrderRelation != null)
{
resetResult.PhysicalTradePLNotValued += CalculatePhysicalTradePL(physicalOrderRelation, exchanger);
}
}
}
}
private InstalmentPayOffParameter GetInstalmentParam(Account account, DateTime tradeDay, TradeDayInfo tradeDayInfo)
{
return(new InstalmentPayOffParameter(_account.GetInstalmentOrders(), account, tradeDayInfo.Instrument, tradeDayInfo.Settings.BuyPrice, tradeDayInfo.Settings.SellPrice, tradeDay));
}
internal void PayoffInstalment(Account account, Guid instrumentId, DateTime tradeDay, TradeDayInfo tradeDayInfo)
{
InstalmentManager instalmentManager = new InstalmentManager(this.GetInstalmentParam(account, tradeDay, tradeDayInfo));
instalmentManager.Payoff();
}
internal static void Save(Account account, AccountClass.Instrument instrument, TradeDayCalculator calculator, TradeDayInfo tradeDayInfo, Settings.Instrument settingInstrument)
{
InstrumentResetItem resetItem = CreateInstrumentResetItem(tradeDayInfo.TradeDay, instrument, calculator.ResetResults, tradeDayInfo.Settings.BuyPrice, tradeDayInfo.Settings.SellPrice);
resetItem.ResetBalance = calculator.Balance;
instrument.AddResetItem(tradeDayInfo.TradeDay, resetItem);
AddOrderResetToAccount(account, calculator.ResetResults);
AddResetResultToOrderDayHistory(account, calculator.ResetResults);
}
private void DoResetByClosePrice(AccountClass.Instrument instrument, DateTime tradeDay, List <TradingDailyQuotation> closeQuotations, TradeDayInfo tradeDayInfo)
{
var settingInstrument = Settings.Setting.Default.GetInstrument(instrument.Id, tradeDay);
var resetItem = instrument.GetResetItem(tradeDay);
if (resetItem != null)
{
Logger.InfoFormat("DoResetByClosePrice modifyClosePrice lastResetItem instrumentId = {0}, tradeDay = {1}, resetBalance = {2}", instrument.Id, tradeDay, resetItem.ResetBalance);
_account.AddBalance(settingInstrument.CurrencyId, -resetItem.ResetBalance, tradeDayInfo.Settings.ResetTime);
}
var quotation = _instrumentDayClosePriceFactory.GetQuotation(settingInstrument, closeQuotations);
if (quotation == null)
{
this.PrintErrorInfo(instrument, tradeDay, closeQuotations);
}
this.DoResetPerTradeDay(instrument, tradeDayInfo, quotation);
}
internal List <PhysicalOrderRelation> UpdatePhysicalOrderRelationValueMatureDate(TradeDayInfo info)
{
List <PhysicalOrderRelation> result = new List <PhysicalOrderRelation>();
foreach (var eachOrderRelation in info.OrderRelations)
{
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (physicalOrderRelation == null)
{
continue;
}
if (physicalOrderRelation.PhysicalValueMatureDay <= info.TradeDay && physicalOrderRelation.RealPhysicalValueMatureDate == null)
{
result.Add(physicalOrderRelation);
physicalOrderRelation.RealPhysicalValueMatureDate = DateTime.Now.Date;
}
}
return(result);
}
internal static TradeDayCalculator CreateForReset(TradeDayInfo tradeDayInfo, InstrumentCloseQuotation closeQuotation)
{
return(CreateCommon(tradeDayInfo, closeQuotation, true));
}
private static void CalculateOrderRelationPLCommon(Order closeOrder, OrderResetResult resetResult, TradeDayInfo tradeDayInfo)
{
PhysicalOrder physicalCloseOrder = closeOrder as PhysicalOrder;
resetResult.TradeDay = tradeDayInfo.TradeDay;
resetResult.CurrencyId = tradeDayInfo.RateSetting.CurrencyId;
resetResult.OrderId = closeOrder.Id;
resetResult.PhysicalPaidAmount = physicalCloseOrder != null ? physicalCloseOrder.PaidAmount : 0;
resetResult.PaidPledgeBalance = physicalCloseOrder != null ? physicalCloseOrder.PaidPledgeBalance : 0;
resetResult.PhysicalOriginValueBalance = physicalCloseOrder != null ? physicalCloseOrder.PhysicalOriginValueBalance : 0;
}
internal static TradeDayCalculator CreateForHistoryOrder(TradeDayInfo tradeDayInfo, InstrumentCloseQuotation closeQuotation)
{
return(CreateCommon(tradeDayInfo, closeQuotation, false));
}
internal static void Calculate(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
CalculateNotValuedOrderRelationPL(tradeDayInfo, exchanger, resetOrderDict, affectedOrders);
CalculateValuedOrderRelationPL(tradeDayInfo, exchanger, resetOrderDict, affectedOrders);
}
internal static decimal CalculateStoragePerLot(Order order, decimal historyStoragePerLot, TradeDayInfo data)
{
decimal result = historyStoragePerLot;
if (data.Settings.IsInterestUseAccountCurrency)
{
decimal storagePerLot = InterestAndStorageCalculater.CalculateStoragePerLot(data.Settings.InterestMultiple, data.Settings.StoragePerLotInterestRateBuy, data.Settings.StoragePerLotInterestRateSell, order.IsBuy);
result += storagePerLot.Exchange(1 / data.RateSetting.RateIn, 1 / data.RateSetting.RateOut, data.RateSetting.RoundDecimals.Max, null);
}
else
{
var storagePerLot = InterestAndStorageCalculater.CalculateStoragePerLot(data.Settings.InterestMultiple, data.Settings.StoragePerLotInterestRateBuy, data.Settings.StoragePerLotInterestRateSell, order.IsBuy);
result += Math.Round(storagePerLot, data.RateSetting.RoundDecimals.Instrument, MidpointRounding.AwayFromZero);
}
return(result);
}
internal static decimal CalculateInterestPerLot(Order order, decimal historyInterestPerLot, TradeDayInfo dayInfo)
{
decimal result = historyInterestPerLot;
if (dayInfo.Settings.IsInterestUseAccountCurrency)
{
if (order.InterestValueDate == null || order.InterestValueDate <= dayInfo.TradeDay)
{
if (dayInfo.Instrument.InterestFormula > 0)
{
result += InterestAndStorageCalculater.CalculateInterestPerLot((int)dayInfo.Instrument.InterestFormula, order.ExecutePrice, dayInfo.Settings.BuyPrice, dayInfo.Settings.SellPrice, dayInfo.Settings.IsUseSettlementPriceForInterest, dayInfo.Settings.InterestMultiple, dayInfo.Instrument.InterestYearDays, dayInfo.Settings.InterestRateBuy, dayInfo.Settings.InterestRateSell, order.IsBuy, order.Owner.ContractSize(dayInfo.TradeDay), dayInfo.RateSetting.RoundDecimals.Instrument);
}
else
{
decimal interestPerLot = InterestAndStorageCalculater.CalculateInterestPerLot((int)dayInfo.Instrument.InterestFormula, order.ExecutePrice, dayInfo.Settings.BuyPrice, dayInfo.Settings.SellPrice, dayInfo.Settings.IsUseSettlementPriceForInterest, dayInfo.Settings.InterestMultiple, dayInfo.Instrument.InterestYearDays, dayInfo.Settings.InterestRateBuy, dayInfo.Settings.InterestRateSell, order.IsBuy, order.Owner.ContractSize(dayInfo.TradeDay), dayInfo.RateSetting.RoundDecimals.Max);
result += interestPerLot.Exchange(1 / dayInfo.RateSetting.RateIn, 1 / dayInfo.RateSetting.RateOut, dayInfo.RateSetting.RoundDecimals.Max, null);
}
}
}
else
{
if (order.InterestValueDate == null || order.InterestValueDate <= dayInfo.TradeDay)
{
result += InterestAndStorageCalculater.CalculateInterestPerLot((int)dayInfo.Instrument.InterestFormula, order.ExecutePrice, dayInfo.Settings.BuyPrice, dayInfo.Settings.SellPrice, dayInfo.Settings.IsUseSettlementPriceForInterest, dayInfo.Settings.InterestMultiple, dayInfo.Instrument.InterestYearDays, dayInfo.Settings.InterestRateBuy, dayInfo.Settings.InterestRateSell, order.IsBuy, order.Owner.ContractSize(dayInfo.TradeDay), dayInfo.RateSetting.RoundDecimals.Instrument);
}
}
return(result);
}
