public OrderPostProcessorStateHook(string purpose, Order order, OrderState orderState, Action<Order, ReporterPokeUnit> hook) {
this.Purpose = purpose;
this.Order = order;
this.OrderState = orderState;
this.Delegate = hook;
this.InvokedThusCanBeDeleted = false;
}
public int InvokeOnceHooksForOrderStateAndDelete(Order order, ReporterPokeUnit pokeUnit) {
int hooksInvoked = 0;
lock (this.hooksLock) {
foreach (OrderPostProcessorStateHook hook in this.hooks) {
string msg = "processing hook [" + hook + "] ";
if (hook.InvokedThusCanBeDeleted) continue;
if (hook.Order != order) continue;
if (hook.OrderState != order.State) continue;
hook.CurrentlyExecuting = true;
hook.Delegate(order, pokeUnit);
hook.CurrentlyExecuting = false;
hook.InvokedThusCanBeDeleted = true;
msg += " ... done";
hooksInvoked++;
}
int hooksRemoved = this.RemoveAllInvoked();
if (hooksRemoved != hooksInvoked) {
string msg = "hooksRemoved[" + hooksRemoved + "] != hooksInvoked[" + hooksInvoked + "]; I don't wanna be stuck on threading issues...";
throw new Exception(msg);
}
}
return hooksInvoked;
}
public Order CreateReplacementOrderInsteadOfRejected(Order rejectedOrderToReplace) {
if (rejectedOrderToReplace == null) {
Assembler.PopupException("order2replace=null why did you call me?");
return null;
}
Order replacement = this.findReplacementOrderForRejectedOrder(rejectedOrderToReplace);
if (replacement != null) {
string msg = "Rejected[" + rejectedOrderToReplace + "] already has a replacement[" + replacement + "] with State[" + replacement.State + "]; ignored rejection duplicates from broker";
this.OrderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedOrderToReplace, msg);
return null;
}
//DateTime todayDate = DateTime.Now.Date;
//if (order.ReplacedByGUID != "" && order.OriginalAlertDate.Date == todayDate) {
// string msg = "order[" + order.ToString() + "] was already replaced today by [" + order.ReplacedByGUID + "]; continuing generating new order";
// Assembler.PopupException(msg);
//order.addMessage(new OrderMessage(msg));
//return null;
//}
if (rejectedOrderToReplace.hasBrokerProvider("CreateReplacementOrderInsteadOfRejected(): ") == false) {
return null;
}
Order replacementOrder = rejectedOrderToReplace.DeriveReplacementOrder();
DateTime serverTimeNow = rejectedOrderToReplace.Alert.Bars.MarketInfo.ConvertLocalTimeToServer(DateTime.Now);
replacementOrder.TimeCreatedBroker = serverTimeNow;
this.OrderProcessor.DataSnapshot.OrderAddSynchronizedAndPropagate(replacementOrder);
this.OrderProcessor.EventDistributor.RaiseOrderStateChanged(this, rejectedOrderToReplace);
this.OrderProcessor.EventDistributor.RaiseOrderReplacementOrKillerCreatedForVictim(this, rejectedOrderToReplace);
return replacementOrder;
}
public void OrderFilledUnlockSequenceSubmitOpening(Order order) {
List<List<Order>> ordersCloseFoundInKeys = new List<List<Order>>();
lock (this.ordersCloseOpen) {
foreach (List<Order> ordersClose in this.ordersCloseOpen.Keys) {
if (ordersClose.Contains(order) == false) continue;
ordersCloseFoundInKeys.Add(ordersClose);
}
foreach (List<Order> ordersCloseFound in ordersCloseFoundInKeys) {
ordersCloseFound.Remove(order);
if (ordersCloseFound.Count == 0) {
List<Order> ordersOpen = this.ordersCloseOpen[ordersCloseFound];
this.ordersCloseOpen.Remove(ordersCloseFound);
if (ordersOpen.Count == 0) continue;
this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(order,
"last CloseOpenSequence order filled, unlocking submission of [" + ordersOpen.Count + "]ordersOpen");
foreach (Order submitting in ordersOpen) {
OrderStateMessage omsg = new OrderStateMessage(submitting, OrderState.Submitting,
"sequence cleared: [" + submitting.State + "]=>[" + OrderState.Submitting + "]"
+ " for [" + ordersOpen.Count + "] fellow ordersOpen"
+ " by orderClose=[" + order + "]");
this.orderProcessor.UpdateOrderStateAndPostProcess(submitting, omsg);
}
BrokerProvider broker = ordersOpen[0].Alert.DataSource.BrokerProvider;
ThreadPool.QueueUserWorkItem(new WaitCallback(broker.SubmitOrdersThreadEntry), new object[] { ordersOpen });
}
}
}
}
public void AddLockAndCreateEmergencyReplacementAndResubmitFor(Order rejectedExitOrder) {
int emergencyCloseAttemptsMax = rejectedExitOrder.Alert.Bars.SymbolInfo.EmergencyCloseAttemptsMax;
if (emergencyCloseAttemptsMax <= 0) return;
try {
throwLogIfNotRejectedClosingOrder(rejectedExitOrder);
} catch (Exception) {
return;
}
OrderPostProcessorEmergencyLock emergencyLock = new OrderPostProcessorEmergencyLock(rejectedExitOrder);
string msg = "Setting an EmergencyLock[" + emergencyLock.ToString() + "]";
Order reason4lock = this.GetReasonForLock(rejectedExitOrder);
bool isEmergencyClosingNow = (reason4lock != null);
if (isEmergencyClosingNow) {
msg = "ALREADY LOCKED (Rejected dupe?): " + msg;
this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedExitOrder, msg);
return;
}
lock (this.emergencyLocks) {
this.emergencyLocks.Add(emergencyLock);
}
CreateEmergencyReplacementAndResubmitFor(rejectedExitOrder);
}
// public Order FindOrderGuidOnRootLevel(string Guid) {
// Order orderParent = null;
// foreach (var each in this.ordersAll) {
// if (each.GUID != Guid) continue;
// orderParent = each;
// break;
// }
// return orderParent;
// }
// public Order FindOrderGuidAmongDerivedsRecursively(string Guid) {
// Order ret = null
// foreach (var each in this.ordersAll) {
// var found = each.FindOrderGuidAmongDerivedsRecursively(Guid);
// if (found == null) continue;
// ret = found;
// break;
// }
// return ret;
// }
//InsertToShadowTreeAfterAddingThisOrderToAnotherOrdersDerivedSlow
public void InsertToShadowTreeRaiseExecutionFormNotification(int indexInsertToIfOrderNotDerived, Order orderAdded) {
Order orderParent = orderAdded.DerivedFrom;
if (orderParent == null) {
base.Insert(indexInsertToIfOrderNotDerived, orderAdded);
}
this.OrderEventDistributor.RaiseOrderAddedExecutionFormNotification(this, orderAdded);
}
protected override bool checkThrowAdd(Order order) {
// don't throw - we are adding into a fake collection anyway (created as new, will be dropped)
if (this.StatesAllowed == OrderStatesCollections.Unknown) return true;
if (this.StateIsAcceptable(order.State)) return true;
string msg = "OrderAdding.State[" + order.State + "] is not in the list of " + StatesAllowed.ToString();
throw new Exception(msg);
}
void raiseOnOrderDoubleClickedChartFormNotification(object sender, Order order) {
if (this.OnOrderDoubleClickedChartFormNotification == null) return;
try {
this.OnOrderDoubleClickedChartFormNotification(sender, new OrderEventArgs(order));
} catch (Exception ex) {
Assembler.PopupException("ExecutionTree::raiseOnOrderDoubleClickedChartFormNotification() Failed to deliver an event", ex);
}
}
void raiseOrderStatsChangedRecalculateWindowTitleExecutionFormNotification(object sender, Order order) {
if (this.OnOrderStatsChangedRecalculateWindowTitleExecutionFormNotification == null) return;
try {
this.OnOrderStatsChangedRecalculateWindowTitleExecutionFormNotification(sender, new OrderEventArgs(order));
} catch (Exception ex) {
Assembler.PopupException("ExecutionTree::raiseOrderStatsChangedRecalculateWindowTitleExecutionFormNotification() Failed to deliver an event", ex);
}
}
protected override bool checkThrowAdd(Order order) {
if (typesAllowed.Contains(order.Alert.MarketLimitStop) == false) {
string msg = "OrderAdding.State[" + order.Alert.MarketLimitStop
+ "] is not in the list of statesAllowed"
+ this.ToString();
throw new Exception(msg);
}
return true;
}
public void RemoveEmergencyLockUserInterrupted(Order reason4lock) {
if (this.GetReasonForLock(reason4lock) == null) {
throw new Exception("CRAZY#54 I was called when the reason4lock still existed?... reason4lock=" + reason4lock);
}
lock (this.interruptedEmergencyLockReasons) {
this.interruptedEmergencyLockReasons.Add(reason4lock);
}
this.removeEmergencyLock(reason4lock, OrderState.EmergencyCloseUserInterrupted);
}
public void OrderAddSynchronizedAndPropagate(Order orderToAdd) {
this.OrdersAll.Insert(0, orderToAdd);
this.SerializerLogrotateOrders.Insert(0, orderToAdd);
this.OrderCountThreadSafe++;
if (orderToAdd.ExpectingCallbackFromBroker) this.OrdersCurrentlyProcessingByBrokerCount++;
this.OrdersTree.InsertToShadowTreeRaiseExecutionFormNotification(0, orderToAdd);
//OrdersTree RaisesTheSameEvent!!! make sure you won't receive it twice
this.OrderProcessor.EventDistributor.RaiseOrderAddedExecutionFormNotification(this, orderToAdd);
}
public void ReplaceRejectedOrder(Order rejectedOrderToReplace) {
if (rejectedOrderToReplace.State != OrderState.Rejected) {
string msg = "will not ReplaceRejectedOrder(" + rejectedOrderToReplace + ") which is not Rejected; continuing";
this.OrderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedOrderToReplace, msg);
Assembler.PopupException(msg);
return;
}
if (rejectedOrderToReplace.Alert.Bars.SymbolInfo.ReSubmitRejected == false) {
string msg = "SymbolInfo[" + rejectedOrderToReplace.Alert.Symbol + "/" + rejectedOrderToReplace.Alert.SymbolClass + "].ReSubmitRejected==false"
+ " will not ReplaceRejectedOrder(" + rejectedOrderToReplace + "); continuing";
this.OrderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(rejectedOrderToReplace, msg);
Assembler.PopupException(msg);
return;
}
Order replacement = this.CreateReplacementOrderInsteadOfRejected(rejectedOrderToReplace);
if (replacement == null) {
string msg = "ReplaceRejectedOrder(" + rejectedOrderToReplace + ") got NULL from CreateReplacementOrder()"
+ "; broker reported twice about rejection, ignored this second callback";
Assembler.PopupException(msg);
//orderToReplace.addMessage(new OrderMessage(msg));
return;
}
double priceScript = replacement.Alert.DataSource.StreamingProvider.StreamingDataSnapshot
.GetAlignedBidOrAskForTidalOrCrossMarketFromStreaming(
replacement.Alert.Bars.Symbol, replacement.Alert.Direction, out replacement.SpreadSide, true);
if (replacement.Alert.PositionAffected != null) { // alert.PositionAffected = null when order created by chart-click-mni
if (replacement.Alert.IsEntryAlert) {
replacement.Alert.PositionAffected.EntryPriceScript = priceScript;
} else {
replacement.Alert.PositionAffected.ExitPriceScript = priceScript;
}
}
if (replacement.Alert.Bars.SymbolInfo.ReSubmittedUsesNextSlippage == true) {
replacement.SlippageIndex++;
}
string msg_replacement = "This is a replacement for order["
+ replacement.ReplacementForGUID + "]; SlippageIndex[" + replacement.SlippageIndex + "]";
this.OrderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(replacement, msg_replacement);
if (replacement.noMoreSlippagesAvailable) {
AddMessageNoMoreSlippagesAvailable(replacement);
//return;
}
double slippage = replacement.Alert.Bars.SymbolInfo.getSlippage(
priceScript, replacement.Alert.Direction, replacement.SlippageIndex, false, false);
replacement.SlippageFill = slippage;
replacement.PriceRequested = priceScript + slippage;
this.SubmitReplacementOrderInsteadOfRejected(replacement);
}
public Order GetReasonForLock(Order order2check4similarLock) {
Order ret = null;
OrderPostProcessorEmergencyLock lock4check = new OrderPostProcessorEmergencyLock(order2check4similarLock);
lock (this.emergencyLocks) {
//bool contains = EmergencyLocks.Contains(orderGenerator);
//bool ret = false;
foreach (OrderPostProcessorEmergencyLock locks in this.emergencyLocks) {
if (locks.Equals(lock4check)) ret = locks.OrderReasonForLock;
}
//if (contains != ret) throw new Exception("contains[" + contains + "] != ret[" + ret + "]");
}
return ret;
}
public void HandleReplaceRejected(Order order) {
if (order.State != OrderState.Rejected) {
//Assembler.PopupException("Man, I resubmit only REJECTED orders, you fed me with State=[" + order.State + "] for order[" + order+ "]");
return;
}
if (order.Alert.Bars.SymbolInfo.ReSubmitRejected == false) {
//Assembler.PopupException("Symbol[" + order.Alert.Bars.Symbol + "] has ReSubmitRejected=[" + reSubmitRejected + "]; returning");
return;
}
if (order.noMoreSlippagesAvailable) {
AddMessageNoMoreSlippagesAvailable(order);
//return;
}
this.ReplaceRejectedOrder(order);
}
public void ReplaceLockingCloseOrder(Order orderRejected, Order orderReplacement) {
lock (this.dictionaryLock) {
Dictionary<List<Order>, List<Order>> sequencerLockCloseOpenCopy = new Dictionary<List<Order>, List<Order>>(this.sequencerLockCloseOpen);
foreach (List<Order> lockingCloseOrders in sequencerLockCloseOpenCopy.Keys) {
List<Order> sequencedOpensAffected = this.sequencerLockCloseOpen[lockingCloseOrders];
if (lockingCloseOrders.Contains(orderRejected) == false) continue;
List<Order> lockingCloseWithReplaced = new List<Order>(lockingCloseOrders);
lockingCloseWithReplaced.Add(orderReplacement);
lockingCloseWithReplaced.Remove(orderRejected);
this.sequencerLockCloseOpen.Add(lockingCloseWithReplaced, sequencedOpensAffected);
this.sequencerLockCloseOpen.Remove(lockingCloseOrders);
}
}
}
bool isExitOrderConsistentLogInconsistency(Order order) {
bool exitOrderHasNoErrors = true;
string errormsg = "";
Position positionShouldBeFilled = order.Alert.PositionAffected;
if (positionShouldBeFilled == null) {
errormsg += "positionShouldBeFilled[" + positionShouldBeFilled + "]=null, ERROR filling order.Alert.PositionAffected !!! ";
order.State = OrderState.IRefuseToCloseNonStreamingPosition;
}
if (positionShouldBeFilled.Shares <= 0) {
errormsg += "Shares<=0 for positionShouldBeFilled[" + positionShouldBeFilled + "]; skipping PositionClose ";
order.State = OrderState.IRefuseToCloseUnfilledEntry;
}
if (positionShouldBeFilled.EntryFilledPrice <= 0) {
errormsg += "EntryPrice<=0 for positionShouldBeFilled[" + positionShouldBeFilled + "]; skipping PositionClose ";
order.State = OrderState.IRefuseToCloseUnfilledEntry;
}
if (positionShouldBeFilled.EntryAlert == null) {
errormsg += "EntryAlert=null for positionShouldBeFilled[" + positionShouldBeFilled + "]; won't close position opened in backtest closing while in streaming ";
order.State = OrderState.IRefuseToCloseUnfilledEntry;
}
if (errormsg == "" && positionShouldBeFilled.EntryAlert.OrderFollowed == null) {
errormsg += "EntryAlert.OrderFollowed=null for positionShouldBeFilled[" + positionShouldBeFilled + "]; won't close position opened in backtest closing while in streaming ";
order.State = OrderState.IRefuseToCloseUnfilledEntry;
}
if (errormsg == "") {
//if (positionShouldBeFilled.EntryAlert.OrderFollowed.StateFilledOrPartially == false) {
// errormsg += "EntryAlert.OrderFollowed.State[" + positionShouldBeFilled.EntryAlert.OrderFollowed.State + "]"
// + " must be [Filled] or [Partially]; skipping PositionClose"
// //+ " for positionShouldBeFilled[" + positionShouldBeFilled + "]"
// ;
// order.State = OrderState.IRefuseToCloseUnfilledEntry;
//}
if (positionShouldBeFilled.EntryAlert.OrderFollowed.QtyFill != positionShouldBeFilled.EntryAlert.Qty) {
errormsg += "EntryAlert.OrderFollowed.QtyFill[" + positionShouldBeFilled.EntryAlert.OrderFollowed.QtyFill + "]"
+ " EntryAlert.Qty[" + positionShouldBeFilled.EntryAlert.Qty + "]"
+ "; skipping PositionClose"
//+ " for positionShouldBeFilled[" + positionShouldBeFilled + "]"
;
//order.State = OrderState.IRefuseToCloseUnfilledEntry;
}
}
if (errormsg != "") {
order.AppendMessage(errormsg);
exitOrderHasNoErrors = false;
}
return exitOrderHasNoErrors;
}
private void removeEmergencyLock(Order filledEmergencyOrder, OrderState stateCompletedOrInterrupted) {
OrderPostProcessorEmergencyLock emergencyLock = new OrderPostProcessorEmergencyLock(filledEmergencyOrder);
string msgPost = "EmergencyLock Removed [" + emergencyLock + "]";
if (this.emergencyLocks.Contains(emergencyLock) == false) {
string msg = "no EmergencyLock to remove: multiple QUIK callbacks? if u can find [" + msgPost
+ "] earlier in thisOrder.Messages then it's ok";
this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(filledEmergencyOrder, msg);
Assembler.PopupException(msg);
//throw new Exception(msg);
return;
}
lock (this.emergencyLocks) {
this.emergencyLocks.Remove(emergencyLock);
}
OrderStateMessage omsgPost = new OrderStateMessage(filledEmergencyOrder, stateCompletedOrInterrupted, msgPost);
this.orderProcessor.UpdateOrderStateAndPostProcess(filledEmergencyOrder, omsgPost);
}
protected void checkOrderThrowInvalid(Order orderToCheck) {
if (orderToCheck.Alert == null) {
throw new Exception("order[" + orderToCheck + "].Alert == Null");
}
if (string.IsNullOrEmpty(orderToCheck.Alert.AccountNumber)) {
throw new Exception("order[" + orderToCheck + "].Alert.AccountNumber IsNullOrEmpty");
}
//if (this.Accounts.Count == 0) {
// throw new Exception("No account for Order[" + orderToCheck.GUID + "]");
//}
if (string.IsNullOrEmpty(orderToCheck.Alert.Symbol)) {
throw new Exception("order[" + orderToCheck + "].Alert.Symbol IsNullOrEmpty");
}
if (orderToCheck.Alert.Direction == null) {
throw new Exception("order[" + orderToCheck + "].Alert.Direction IsNullOrEmpty");
}
if (orderToCheck.PriceRequested == 0 &&
(orderToCheck.Alert.MarketLimitStop == MarketLimitStop.Stop || orderToCheck.Alert.MarketLimitStop == MarketLimitStop.Limit)) {
throw new Exception("order[" + orderToCheck + "].Price[" + orderToCheck.PriceRequested + "] should be != 0 for Stop or Limit");
}
}
public void OrderFilledUnlockSequenceSubmitOpening(Order orderClosed) {
List<List<Order>> lockingClosesFound = new List<List<Order>>();
lock (this.dictionaryLock) {
// if among all the keys we have an order, then we should have Open orders sequenced
foreach (List<Order> lockingCloseOrders in this.sequencerLockCloseOpen.Keys) {
if (lockingCloseOrders.Contains(orderClosed) == false) continue;
lockingClosesFound.Add(lockingCloseOrders);
}
// analyzing all locks for all symbols to find out whether this closed order released the lock
foreach (List<Order> lockingCloseFound in lockingClosesFound) {
// delete the locking order from the list (most likely containing 1 order)
lockingCloseFound.Remove(orderClosed);
if (lockingCloseFound.Count > 0) continue;
// delete the list of locks from global dictionary
List<Order> ordersOpen = this.sequencerLockCloseOpen[lockingCloseFound];
this.sequencerLockCloseOpen.Remove(lockingCloseFound);
this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(orderClosed,
"last CloseOpenSequence order filled, unlocking submission of ["
+ ordersOpen.Count + "]ordersOpen");
if (ordersOpen.Count == 0) continue;
// submitting all released opening orders
foreach (Order submitting in ordersOpen) {
OrderStateMessage omsg = new OrderStateMessage(submitting, OrderState.Submitting,
"sequence cleared: [" + submitting.State + "]=>[" + OrderState.Submitting + "]"
+ " for [" + ordersOpen.Count + "] fellow ordersOpen"
+ " by orderClose=[" + orderClosed + "]");
this.orderProcessor.UpdateOrderStateAndPostProcess(submitting, omsg);
}
BrokerProvider broker = ordersOpen[0].Alert.DataSource.BrokerProvider;
ThreadPool.QueueUserWorkItem(new WaitCallback(broker.SubmitOrdersThreadEntryDelayed),
new object[] { ordersOpen, ordersOpen[0].Alert.Bars.SymbolInfo.SequencedOpeningAfterClosedDelayMillis });
}
}
}
public virtual void OrderSubmit(Order order) {
throw new Exception("please override BrokerProvider::SubmitOrder() for BrokerProvider.Name=[" + Name + "]");
}
private void RemoveOrdersPendingOnFilledCallback(Order orderExecuted, string msig) {
msig = "RemoveOrdersPendingOnFilledCallback(): ";
//if (OrderStatesCollections.CemeteryHealthy.OrderStates.Contains(orderExecuted.State) == false) return;
//string msg = this.OrderProcessor.DataSnapshot.OrdersPending.ToStringSummary();
//bool removed = this.OrderProcessor.DataSnapshot.OrdersPending.Remove(orderExecuted);
//msg += " ...REMOVED(" + removed + ")=> " + this.OrderProcessor.DataSnapshot.OrdersPending.ToStringSummary();
string msg = this.OrderProcessor.DataSnapshot.FindStateLaneExpectedByOrderState(orderExecuted.State).ToString();
if (orderExecuted.Alert.IsExitAlert && orderExecuted.Alert.PositionAffected.IsExitFilled == false) {
msg = "WARNING_POSITION_STILL_OPEN "
//+ " Alert.isExitAlert && PositionAffected.IsExitFilled=false"
+ msg;
}
orderExecuted.AppendMessage(msig + msg);
}
public void CallbackOrderStateReceived(Order orderWithNewState) {
string msig = "BrokerProvider::CallbackOrderStateReceived(): orderExecuted.State=[" + orderWithNewState.State + "]: ";
string msg = "";
try {
switch (orderWithNewState.State) {
case OrderState.Active: //«начение Ђ1ї соответствует состо¤нию Ђјктивнаї
Order mustBeSame = this.OrderProcessor.DataSnapshot.OrdersPending.FindSimilarNotSamePendingOrder(orderWithNewState);
//Order mustBeSame = this.OrderProcessor.DataSnapshot.OrdersAll.FindSimilarNotSamePendingOrder(orderWithNewState);
if (mustBeSame == null) break;
bool identical = mustBeSame.Alert.IsIdenticalOrderlessPriceless(orderWithNewState.Alert);
if (identical == false) {
msg += "PENDING_MISSING: How come it wasn't added in OrderSubmit()??? orderExecuted["
+ orderWithNewState + "] mustBeSame[" + mustBeSame + "]";
//orderExecuted.AppendMessage(msig + msg);
//Assembler.PopupException(msg);
} else {
msg += "SECOND_PENDING_ADDED_OK";
//orderExecuted.AppendMessage(msig + msg);
//Assembler.PopupException(msg);
}
break;
case OrderState.Killed: //Ђ2ї - Ђ—н¤таї
this.OrderProcessor.RemovePendingAlertsForVictimOrderMustBePostKill(orderWithNewState, msig);
break;
case OrderState.Rejected: //Ђ2ї - Ђ—н¤таї
case OrderState.SLAnnihilated:
case OrderState.TPAnnihilated:
case OrderState.FilledPartially: // иначе Ђ»сполненаї
case OrderState.Filled: // иначе Ђ»сполненаї
break;
default:
msg += "STATE_UNEXPECTED";
orderWithNewState.AppendMessage(msig + msg);
break;
}
this.RemoveOrdersPendingOnFilledCallback(orderWithNewState, msig);
} catch (Exception e) {
this.StatusReporter.PopupException(e);
}
try {
this.OrderProcessor.InvokeHooksAndSubmitNewAlertsBackToBrokerProvider(orderWithNewState);
} catch (Exception e) {
this.StatusReporter.PopupException(e);
}
}
public virtual void ModifyOrderTypeAccordingToMarketOrderAs(Order order) {
string msg = Name + "::ModifyOrderTypeAccordingToMarketOrderAs():"
+ " Guid[" + order.GUID + "]" + " SernoExchange[" + order.SernoExchange + "]"
+ " SernoSession[" + order.SernoSession + "]";
order.CurrentBid = this.StreamingProvider.StreamingDataSnapshot.BestBidGetForMarketOrder(order.Alert.Symbol);
order.CurrentAsk = this.StreamingProvider.StreamingDataSnapshot.BestAskGetForMarketOrder(order.Alert.Symbol);
double priceBestBidAsk = this.StreamingProvider.StreamingDataSnapshot.BidOrAskFor(
order.Alert.Symbol, order.Alert.PositionLongShortFromDirection);
switch (order.Alert.MarketLimitStop) {
case MarketLimitStop.Market:
//if (order.PriceRequested != 0) {
// string msg1 = Name + "::OrderSubmit(): order[" + order + "] is MARKET, dropping Price[" + order.PriceRequested + "] replacing with current Bid/Ask ";
// order.addMessage(new OrderStateMessage(order, order.State, msg1));
// Assembler.PopupException(msg1);
// order.PriceRequested = 0;
//}
if (order.Alert.Bars == null) {
msg = "order.Bars=null; can't align order and get Slippage; returning with error // " + msg;
Assembler.PopupException(msg);
//order.AppendMessageAndChangeState(new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg));
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg));
throw new Exception(msg);
}
switch (order.Alert.MarketOrderAs) {
case MarketOrderAs.MarketZeroSentToBroker:
order.PriceRequested = 0;
msg = "SymbolInfo[" + order.Alert.Symbol + "/" + order.Alert.SymbolClass + "].OverrideMarketPriceToZero==true"
+ "; setting Price=0 (Slippage=" + order.SlippageFill + ") //" + msg;
break;
case MarketOrderAs.MarketMinMaxSentToBroker:
order.Alert.MarketLimitStop = MarketLimitStop.Limit;
msg = this.ModifyOrderTypeAccordingToMarketOrderAsBrokerSpecificInjection(order);
msg = "[" + order.Alert.MarketLimitStop + "]=>[" + MarketLimitStop.Limit + "](" + order.Alert.MarketOrderAs + ") // " + msg;
break;
case MarketOrderAs.LimitCrossMarket:
order.Alert.MarketLimitStop = MarketLimitStop.Limit;
msg = "PreSubmit: doing nothing for Alert.MarketOrderAs=[" + order.Alert.MarketOrderAs + "]"
+ " //" + msg;
break;
case MarketOrderAs.LimitTidal:
order.Alert.MarketLimitStop = MarketLimitStop.Limit;
msg = "PreSubmit: doing nothing for Alert.MarketOrderAs=[" + order.Alert.MarketOrderAs + "]"
+ " //" + msg;
break;
default:
msg = "no handler for Market Order with Alert.MarketOrderAs[" + order.Alert.MarketOrderAs + "] // " + msg;
OrderStateMessage newOrderState2 = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState2);
throw new Exception(msg);
}
//if (order.Alert.Bars.SymbolInfo.OverrideMarketPriceToZero == true) {
//} else {
// if (order.PriceRequested == 0) {
// base.StreamingProvider.StreamingDataSnapshot.getAlignedBidOrAskTidalOrCrossMarketFromStreaming(
// order.Alert.Symbol, order.Alert.Direction, out order.PriceRequested, out order.SpreadSide, ???);
// order.PriceRequested += order.Slippage;
// order.PriceRequested = order.Alert.Bars.alignOrderPriceToPriceLevel(order.PriceRequested, order.Alert.Direction, order.Alert.MarketLimitStop);
// }
//}
//order.addMessage(new OrderStateMessage(order, order.State, msg));
//Assembler.PopupException(msg);
break;
case MarketLimitStop.Limit:
order.SpreadSide = OrderSpreadSide.ERROR;
switch (order.Alert.Direction) {
case Direction.Buy:
case Direction.Cover:
if (priceBestBidAsk <= order.PriceRequested) order.SpreadSide = OrderSpreadSide.BidTidal;
break;
case Direction.Sell:
case Direction.Short:
if (priceBestBidAsk >= order.PriceRequested) order.SpreadSide = OrderSpreadSide.AskTidal;
break;
default:
msg += " No Direction[" + order.Alert.Direction + "] handler for order[" + order.ToString() + "]"
+ "; must be one of those: Buy/Cover/Sell/Short";
//orderProcessor.updateOrderStatusError(order, OrderState.Error, msg);
OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.Error, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState);
throw new Exception(msg);
}
break;
case MarketLimitStop.Stop:
case MarketLimitStop.StopLimit:
order.SpreadSide = OrderSpreadSide.ERROR;
switch (order.Alert.Direction) {
case Direction.Buy:
case Direction.Cover:
if (priceBestBidAsk >= order.PriceRequested) order.SpreadSide = OrderSpreadSide.AskTidal;
break;
case Direction.Sell:
case Direction.Short:
if (priceBestBidAsk <= order.PriceRequested) order.SpreadSide = OrderSpreadSide.BidTidal;
break;
default:
msg += " No Direction[" + order.Alert.Direction + "] handler for order[" + order.ToString() + "]"
+ "; must be one of those: Buy/Cover/Sell/Short";
//orderProcessor.updateOrderStatusError(order, OrderState.Error, msg);
OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.Error, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState);
throw new Exception(msg);
}
break;
default:
msg += " No MarketLimitStop[" + order.Alert.MarketLimitStop + "] handler for order[" + order.ToString() + "]"
+ "; must be one of those: Market/Limit/Stop";
//orderProcessor.updateOrderStatusError(order, OrderState.Error, msg);
OrderStateMessage omsg = new OrderStateMessage(order, OrderState.Error, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, omsg);
throw new Exception(msg);
}
order.AppendMessage(msg);
}
public virtual string ModifyOrderTypeAccordingToMarketOrderAsBrokerSpecificInjection(Order order) {
return "";
}
public virtual void OrderPreSubmitEnrichCheckThrow(Order order) {
string msg = Name + "::OrderPreSubmitChecker():"
+ " Guid[" + order.GUID + "]" + " SernoExchange[" + order.SernoExchange + "]"
+ " SernoSession[" + order.SernoSession + "]";
if (this.StreamingProvider == null) {
msg = " StreamingProvider=null, can't get last/fellow/crossMarket price // " + msg;
OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState);
throw new Exception(msg);
}
try {
this.checkOrderThrowInvalid(order);
} catch (Exception ex) {
msg = ex.Message + " //" + msg;
//orderProcessor.updateOrderStatusError(order, OrderState.ErrorOrderInconsistent, msg);
OrderStateMessage newOrderState = new OrderStateMessage(order, OrderState.ErrorOrderInconsistent, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, newOrderState);
throw new Exception(msg, ex);
}
order.CurrentBid = this.StreamingProvider.StreamingDataSnapshot.BestBidGetForMarketOrder(order.Alert.Symbol);
order.CurrentAsk = this.StreamingProvider.StreamingDataSnapshot.BestAskGetForMarketOrder(order.Alert.Symbol);
this.OrderPreSubmitEnrichBrokerSpecificInjection(order);
// moved to orderProcessor::CreatePropagateOrderFromAlert()
// this.ModifyOrderTypeAccordingToMarketOrderAs(order);
if (order.Alert.Strategy.Script != null) {
Order reason4lock = this.OrderProcessor.OPPemergency.GetReasonForLock(order);
bool isEmergencyClosingNow = (reason4lock != null);
//bool positionWasFilled = this.orderProcessor.positionWasFilled(order);
if (order.Alert.IsEntryAlert && isEmergencyClosingNow) { // && positionWasFilled
//OrderState IRefuseUntilemrgComplete = this.orderProcessor.OPPemergency.getRefusalForEmergencyState(reason4lock);
OrderState IRefuseUntilemrgComplete = OrderState.IRefuseOpenTillEmergencyCloses;
msg = "Reason4lock: " + reason4lock.ToString();
OrderStateMessage omsg = new OrderStateMessage(order, IRefuseUntilemrgComplete, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(order, omsg);
throw new Exception(msg);
}
}
}
public virtual void OrderPreSubmitEnrichBrokerSpecificInjection(Order order) {
}
public virtual void OrderKillSubmitUsingKillerOrder(Order killerOrder) {
if (string.IsNullOrEmpty(killerOrder.VictimGUID)) {
throw new Exception("killerOrder.KillerForGUID=EMPTY");
}
if (killerOrder.VictimToBeKilled == null) {
throw new Exception("killerOrder.VictimToBeKilled=null");
}
string msg = "State[" + killerOrder.State + "]"
+ " [" + killerOrder.Alert.Symbol + "/" + killerOrder.Alert.SymbolClass + "]"
+ " VictimToBeKilled.SernoExchange[" + killerOrder.VictimToBeKilled.SernoExchange + "]";
msg = Name + "::UsingKillerOrder(): " + msg;
Assembler.PopupException(msg);
OrderStateMessage omsgKiller = new OrderStateMessage(killerOrder, OrderState.KillerPreSubmit, msg);
this.OrderProcessor.UpdateOrderStateAndPostProcess(killerOrder, omsgKiller);
this.OrderKillSubmit(killerOrder.VictimToBeKilled);
}
public virtual void OrderKillSubmit(Order victimOrder) {
throw new Exception("please override BrokerProvider::OrderKillSubmit() for BrokerProvider.Name=[" + Name + "]");
}
public virtual void CancelReplace(Order order, Order newOrder) {
throw new Exception("please override BrokerProvider::CancelReplace() for BrokerProvider.Name=[" + Name + "]");
}
