protected override void InnerVerify(Order order, bool isPlaceByRiskMonitor, AppType appType, PlaceContext context)
{
base.InnerVerify(order, isPlaceByRiskMonitor, appType, context);
this.VerifyPlaceSettings(order, context);
}
protected override void VerifyBPointAndMaxDQLot(Order order, PlaceContext context)
{
this.VerifyNetLot(order);
this.VerifyMaxDQLot(order, context);
}
protected override void InnerVerify(Order order, bool isPlaceByRiskMonitor, AppType appType, PlaceContext context)
{
this.VerifyInstrumentAcceptableOrderType(order, context);
Order amendedOrder = order.Owner.AmendedOrder;
if (amendedOrder != null && this.IsTradeOptionAndSetPriceEqual(order, amendedOrder))
{
return;
}
base.InnerVerify(order, isPlaceByRiskMonitor, appType, context);
this.VerifyCommon(order, isPlaceByRiskMonitor, appType);
}
protected override void VerifyInstrumentAcceptableOrderType(Order order, PlaceContext context)
{
}
public PlaceRepository(PlaceContext placeContext)
{
this.placeContext = placeContext;
}
protected override bool IsTimingAcceptable(DateTime baseTime, Transaction tran, PlaceContext context)
{
bool isTimingAcceptable = tran.EndTime > baseTime;
switch (tran.OrderType)
{
case OrderType.MarketOnOpen:
isTimingAcceptable = true;
break;
case OrderType.MarketOnClose:
string errorDetail;
isTimingAcceptable = tran.TradingInstrument.CanPlace(tran.SubmitTime, (OrderType.MarketOnClose).IsPendingType(), tran.AccountInstrument.GetQuotation(tran.SubmitorQuotePolicyProvider), context, out errorDetail);
if (!isTimingAcceptable)
{
var tradeDay = Settings.Setting.Default.GetTradeDay(context.TradeDay);
var systemParameter = Settings.Setting.Default.SystemParameter;
isTimingAcceptable = (tran.SubmitTime >= tran.SettingInstrument(context.TradeDay).DayOpenTime&&
tran.SubmitTime <= tran.SettingInstrument(context.TradeDay).DayCloseTime.AddMinutes(0 - systemParameter.MooMocAcceptDuration));
}
break;
}
return(isTimingAcceptable);
}
protected override bool IsTimingAcceptable(DateTime baseTime, Transaction tran, PlaceContext context)
{
return(tran.EndTime > baseTime);
}
protected override void InnerVerify(Order order, PlaceContext context)
{
}
private string GetErrorMsg(Order order, PlaceContext context)
{
return(string.Format("Order side is not allowed, AllowedSpotTradeOrderSides={0}, AllowedNewTradeSides={1}", order.Instrument(context.TradeDay).AllowedSpotTradeOrderSides, order.Owner.DealingPolicyPayload(context.TradeDay).AllowedNewTradeSides));
}
public PlacesController(PlaceContext context)
{
_context = context;
}
protected abstract void InnerVerify(Order order, PlaceContext context);
protected override void InnerVerify(Order order, PlaceContext context)
{
this.VerifyPhysicalTradeSide(order);
this.VerifyCommon(order, context);
}
internal void Verify(Order order, PlaceContext context)
{
this.InnerVerify(order, context);
}
public bool CanPlace(DateTime baseTime, bool isPending, Quotations.Quotation quotation, PlaceContext context, out string errorDetail)
{
errorDetail = string.Empty;
var instrument = this.SettingInstrument;
bool isPlaceAllowd = this.IsPlaceAllowed;
if (context.IsBook)
{
baseTime = context.ExecuteTime.Value;
isPlaceAllowd = true;
}
if (context.IsBook)
{
instrument = Settings.Setting.Default.GetInstrument(instrument.Id, context.TradeDay);
}
if (!instrument.IsActive)
{
return(false);
}
if (instrument.ExchangeSystem != ExchangeSystem.Local)
{
return(true);
}
if (isPlaceAllowd && (instrument.DayOpenTime + TimeSpan.FromSeconds(instrument.FirstOrderTime)) <= baseTime && baseTime <= instrument.DayCloseTime)
{
bool isOnPriceLimit = InstrumentPriceStatusManager.Default.IsOnPriceLimit(instrument.OriginCode);
if (instrument.IsPriceEnabled && !isOnPriceLimit)
{
if (instrument.InactiveTime <= 0)
{
return(true);
}
else
{
DateTime compareTime = quotation != null ? quotation.Timestamp : instrument.PriceEnableTime;
if (compareTime < instrument.PriceEnableTime)
{
compareTime = instrument.PriceEnableTime;
}
double inActiveTime = (Market.MarketManager.Now - compareTime).TotalSeconds;
if (inActiveTime < instrument.InactiveTime)
{
return(true);
}
else
{
errorDetail = string.Format("instrument id = {0} exceed inactive time = {1}, instrument.InactiveTime = {2} compareTime = {3}, priceEnableTime = {4} QuotationTimestatp = {5}", instrument.Id, inActiveTime, instrument.InactiveTime, compareTime, instrument.PriceEnableTime, quotation != null? quotation.Timestamp.ToString(): string.Empty);
return(false);
}
}
}
else
{
errorDetail = string.Format("IsPriceEnabled = {0}, isOnPriceLimit = {1}", instrument.IsPriceEnabled, isOnPriceLimit);
return(false);
}
}
else
{
errorDetail = string.Format("baseTime={0}, isPending={1}; isActive={2}, isPlaceAllowed={3}, isPriceEnabled={4},dayOpenTime={5},dayCloseTime={6}, CanPlacePendingOrderAtAnyTime = {7}", baseTime, isPending, instrument.IsActive, isPlaceAllowd, instrument.IsPriceEnabled, instrument.DayOpenTime, instrument.DayCloseTime, instrument.CanPlacePendingOrderAtAnyTime);
return(instrument.CanPlacePendingOrderAtAnyTime && isPending);
}
}
protected override void InnerVerify(Order order, bool isPlaceByRiskMonitor, AppType appType, PlaceContext context)
{
base.InnerVerify(order, isPlaceByRiskMonitor, appType, context);
Transaction tran = order.Owner;
if (!order.Owner.TradePolicyDetail(context.TradeDay).IsTradeActive)
{
throw new TransactionServerException(TransactionError.TradePolicyIsNotActive);
}
}
public PlaceRepository(PlaceContext context)
{
_context = context;
}
internal static void VerifyForExecuting(this Transaction tran, bool isPlaceByRiskMonitor, AppType appType, PlaceContext context)
{
var executeVerifier = OrderFacade.Default.GetExecuteVerifier(tran);
foreach (Order order in tran.Orders)
{
executeVerifier.Verify(order, isPlaceByRiskMonitor, appType, context);
}
}
