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 + "]"); }