/// <summary> /// Add the signal to the list of the bar with barNo /// </summary> /// <param name="barNo"></param> /// <param name="signal"></param> public void AddTradeSignal(int barNo, SortedDictionary <int, List <TradeSignal> > listSignals, TradeSignal signal) { List <TradeSignal> list_signal; if (!listSignals.TryGetValue(barNo, out list_signal)) { list_signal = new List <TradeSignal>(); } // else // listSignals.Remove(barNo); list_signal.Add(signal); //listSignals.Add(barNo, list_signal); listSignals[barNo] = list_signal; IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: AddTradeSignal list_signal.Count={1}, listSignals.Count={2}", CurrentBar, list_signal.Count, listSignals.Count)); if (listSignals.Count < 5) { foreach (KeyValuePair <int, List <TradeSignal> > m in listSignals) { List <TradeSignal> mm = m.Value as List <TradeSignal>; foreach (TradeSignal ts in mm) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: AddTradeSignal SortedDictionary key={1}, SignalType={2}", CurrentBar, m.Key, ts.SignalType.ToString())); } } } }
/// <summary> /// OnOrderUpdate->OnExecutionUpdate->OnPositionUpdate /// OnPositionUpdate: check new trade, change position for curTrade, no order update; /// OnExecutionUpdate: check filled order, update the new entry order and liquidate order; /// OnOrderUpdate: deal with working order, rejected/cancelled orders; /// </summary> /// <param name="order"></param> /// <param name="limitPrice"></param> /// <param name="stopPrice"></param> /// <param name="quantity"></param> /// <param name="filled"></param> /// <param name="averageFillPrice"></param> /// <param name="orderState"></param> /// <param name="time"></param> /// <param name="error"></param> /// <param name="comment"></param> protected override void OnOrderUpdate(Cbi.Order order, double limitPrice, double stopPrice, int quantity, int filled, double averageFillPrice, Cbi.OrderState orderState, DateTime time, Cbi.ErrorCode error, string comment) { //if(BarsInProgress !=0) return; IndicatorProxy.Log2Disk = true; if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBars[BarsInProgress] + "[" + BarsInProgress + "]:OnOrderUpdate IsUnmanaged=" + IsUnmanaged); } //The logic is implemented in the method below CurrentTrade.OnCurOrderUpdate(order, limitPrice, stopPrice, quantity, filled, averageFillPrice, orderState, time, error, comment); return; //The order execution is implemented in the method below if (IsUnmanaged) { OnOrderUpdateUM(order, limitPrice, stopPrice, quantity, filled, averageFillPrice, orderState, time, error, comment); } else { OnOrderUpdateMG(order, limitPrice, stopPrice, quantity, filled, averageFillPrice, orderState, time, error, comment); } }
/// <summary> /// Get the signal list for the bar by signal type /// </summary> /// <param name="barNo"></param> /// <param name="signal_type"></param> /// <returns></returns> public List <TradeSignal> GetTradeSignalByType(int barNo, SortedDictionary <int, List <TradeSignal> > listSignals, TradeSignalType signal_type) { List <TradeSignal> list_signal = GetTradeSignals(barNo, listSignals); IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: GetTradeSignalByType signal_type={1}, list_signal={2}, listSignals.Count={3}", CurrentBar, signal_type, list_signal, listSignals.Count)); if (list_signal != null) { List <TradeSignal> list_sigByType = new List <TradeSignal>(); foreach (TradeSignal sig in list_signal) { //if(list_signal.Count >= 1) if (signal_type == sig.SignalType) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: GetTradeSignalByType== signal_type={1}, sig.SignalType={2}, list_signal.Count={3}", CurrentBar, signal_type, sig.SignalType, list_signal.Count)); list_sigByType.Add(sig); } } if (list_sigByType.Count > 0) { return(list_sigByType); } } return(null); }
protected override void OnBarUpdate() { if (CurrentBar < BarsRequiredToTrade) { return; } giPctSpd.Update(); IndicatorProxy.Update(); if (CheckPnLByBarsSinceEn()) { OnExitPositions(null); } // if(BarsInProgress == BarsArray.Length-1) // OnTradeByPctSpd(); // Note: Bars are added to the BarsArray and can be accessed via an index value // E.G. BarsArray[1] ---> Accesses the 1 minute Bars added above // if (adx1 == null) // adx1 = ADX(BarsArray[1], 14); // OnBarUpdate() will be called on incoming tick events on all Bars objects added to the strategy // We only want to process events on our primary Bars object (main instrument) (index = 0) which // is set when adding the strategy to a chart if (BarsInProgress != 0) { return; } if (CurrentBars[0] < 0 || CurrentBars[1] < 0) { return; } // Checks if the 14 period ADX on both instruments are trending (above a value of 30) if (adx[0] > 30 && adx1[0] > 30) { // If RSI crosses above a value of 30 then enter a long position via a limit order if (CrossAbove(rsi, 30, 1)) { // Draws a square 1 tick above the high of the bar identifying when a limit order is issued Draw.Square(this, "My Square" + CurrentBar, false, 0, High[0] + TickSize, Brushes.DodgerBlue); // Enter a long position via a limit order at the current ask price //EnterLongLimit(GetCurrentAsk(), "RSI"); //EnterLong(1); // EnterLong(0, 1, "RSI"); // EnterShort(1, 1, "RSI"); // EnterShort(2, 1, "RSI"); } } // Any open long position will exit if RSI crosses below a value of 75 // This is in addition to the trail stop set in the OnStateChange() method under State.Configure if (CrossBelow(rsi, 75, 1)) { //ExitLong(); // ExitLong(0, 1, "ExitRSI", "RSI"); // ExitShort(1, 1, "ExitRSI", "RSI"); // ExitShort(2, 1, "ExitRSI", "RSI"); } }
/// <summary> /// /// </summary> public virtual void TakeTradeAction() { //CurrentTrade.TradeAction = GetTradeAction(CurrentBar);//?? try { TradeAction ta = CurrentTrade.TradeAction; if (ta == null || ta.ActionStatus == TradeActionStatus.Executed) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}:TakeTradeAction called, CurrentTrade.TradeAction=null or Executed=={1}", CurrentBar, ta.ActionStatus.ToString())); return; } String sigName = "UnKnown"; if (ta.EntrySignal != null) { sigName = ta.EntrySignal.SignalName; } if (ta.StopLossSignal != null) { sigName = ta.StopLossSignal.SignalName; } if (ta.ProfitTargetSignal != null) { sigName = ta.ProfitTargetSignal.SignalName; } if (ta.ScaleOutSignal != null) { sigName = ta.ScaleOutSignal.SignalName; } IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBar + ":TakeTradeAction" + ";SignalName=" + sigName + ";ActionName=" + ta.ActionName + ";ActionType=" + ta.ActionType.ToString() + ";CurrentTrade.TDID=" + CurrentTrade.TradeID + ";OcoID=" + CurrentTrade.OcoID + ";HasPosition=" + HasPosition()); ta.ActionStatus = TradeActionStatus.Executed; switch (ta.ActionType) { case TradeActionType.EntrySimple: case TradeActionType.Bracket: PutEntryTrade(); break; case TradeActionType.ExitOCO: PutExitTrade(); break; case TradeActionType.ExitSimple: PutLiquidateTrade(); break; } } catch (Exception ex) { IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBar + ":Exception TakeTradeAction--" + ex.StackTrace); } }
/// <summary> /// Get the signal list for the bar /// </summary> /// <param name="barNo"></param> /// <returns></returns> public List <TradeSignal> GetTradeSignals(int barNo, SortedDictionary <int, List <TradeSignal> > listSignals) { List <TradeSignal> list_signal; listSignals.TryGetValue(barNo, out list_signal); // return null; //else IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: GetTradeSignals list_signal.Count={1}, listSignals.Count={2}", CurrentBar, list_signal, listSignals.Count)); return(list_signal); }
protected double GetTimeSinceEntry() { int bse = BarsSinceEntryExecution(); double timeSinceEn = -1; if (bse > 0) { timeSinceEn = IndicatorProxy.GetMinutesDiff(Time[0], Time[bse]); } return(timeSinceEn); }
/// <summary> /// Check if now is the time to liquidate /// </summary> /// <param name="timeH">time hour</param> /// <param name="timeM">time min</param> /// <returns></returns> public bool IsLiquidateTime(int timeH, int timeM) { int time_now = IndicatorProxy.GetTimeByHM(Time[0].Hour, Time[0].Minute, true); int time_lastBar = IndicatorProxy.GetTimeByHM(Time[1].Hour, Time[1].Minute, true); int time_liq = IndicatorProxy.GetTimeByHM(timeH, timeM, true); bool isTime = false; if (time_now == time_liq || (time_liq > time_lastBar && time_liq <= time_now)) { isTime = true; } return(isTime); }
// Define what actions to take when the event is raised. void OnTradeByPairSpdRs(object sender, IndicatorEventArgs e) { IndicatorSignal isig = e.IndSignal; //Print(String.Format("{0}:OnTradeByPairSpdRs triggerred {1} Bip{2}: Spread={3}, Middle={4}", //CurrentBars[BarsInProgress], isig.SignalName, BarsInProgress, giSpdRs.Spread[0], giSpdRs.Middle[0])); if (e.IndSignal.SignalName != null && HasPairPosition()) { OnExitPositions(e); } else if (e.IndSignal.SignalName != null && IsTradingTime(IndicatorProxy.GetTimeByHM(TG_OpenStartH, TG_OpenStartM, true))) { OnEntryPositions(e); } }
public bool HasPairPosition(int startIndex) { if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, 0); } bool pos = false; if (GetMarketPosition(startIndex) != MarketPosition.Flat && GetMarketPosition(startIndex + 1) != MarketPosition.Flat) { pos = true; } return(pos); }
public override bool IsTradingTime(int session_start) { //Bars.Session.GetNextBeginEnd(DateTime time, out DateTime sessionBegin, out DateTime sessionEnd) int time_start = IndicatorProxy.GetTimeByHM(TG_TradeStartH, TG_TradeStartM, true); int time_end = IndicatorProxy.GetTimeByHM(TG_TradeEndH, TG_TradeEndM, true); int time_now = ToTime(Time[0]); bool isTime = (BarsPeriod.BarsPeriodType == BarsPeriodType.Day)? true : false; if (time_now >= session_start && time_now >= time_start && time_now <= time_end) { isTime = true; } // Print(String.Format("{0}: time_now={1}, session_start={2}, time_start={3}, time_end={4}, isTime={5}", // CurrentBar, time_now, session_start, time_start, time_end, isTime)); return(isTime); }
// Define what actions to take when the event is raised. void OnTradeBySpdLadder(object sender, IndicatorEventArgs e) { IndicatorSignal isig = e.IndSignal; if (this.PrintOut > 1) { Print(String.Format("{0}:OnTradeBySpdLadder triggerred {1} Bip{2}: Spread={3}, HiAllTime={4}", CurrentBars[BarsInProgress], isig.SignalName, BarsInProgress, giSpdLadder.Spread[0], giSpdLadder.HiAllTime)); } if (e.IndSignal.SignalName != null && HasPairPosition()) { OnExitPositions(e); } else if (e.IndSignal.SignalName != null && IsTradingTime(IndicatorProxy.GetTimeByHM(TG_OpenStartH, TG_OpenStartM, true))) { OnEntryPositions(e); } }
/// <summary> /// Only updated on live/sim trading, not triggered at back-testing; /// The evernt posted tick by tick at sim/living trading with poistion hold; /// </summary> /// <param name="account"></param> /// <param name="accountItem"></param> /// <param name="value"></param> protected override void OnAccountItemUpdate(Cbi.Account account, Cbi.AccountItem accountItem, double value) { if (account == null || accountItem == null || IndicatorProxy == null) { return; } if (accountItem == AccountItem.UnrealizedProfitLoss && PrintOut > 2 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), //":OnAccountItemUpdate" CurrentBar + ":OnAccountItemUpdate" + ";Name=" + account.DisplayName + ";Item=" + accountItem.ToString() + ";value=" + value + ";DailyLossLmt=" + account.DailyLossLimit + ";Status=" + account.AccountStatus.ToString() ); } }
// Define what actions to take when the event is raised. void OnTradeByPairPctSpd(object sender, IndicatorEventArgs e) { IndicatorSignal isig = e.IndSignal; Print(String.Format("{0}:OnTradeByPairPctSpd triggerred {1} Bip{2}: PlotPctSpd={3}, PctChgSpdThresholdEn={4}", CurrentBars[BarsInProgress], isig.SignalName, BarsInProgress, giPairPctSpd.PlotPctSpd[0], giPairPctSpd.PctChgSpdThresholdEn)); if (IsTradingTime(IndicatorProxy.GetTimeByHM(TG_OpenStartH, TG_OpenStartM, true)) && giPairPctSpd.PlotPctSpd[0] <= PctChgSpdThresholdEn) { OnEntryPositions(e); } else { OnExitPositions(e); } /* * int q_max = GetTradeQuantity(giPctSpd.PctChgMaxBip, this.MM_ProfitFactorMax); * int q_min = GetTradeQuantity(giPctSpd.PctChgMinBip, this.MM_ProfitFactorMin); * * //exit at 9:40 am ct * if(isig.SignalName == giPctSpd.SignalName_ExitForOpen) { * Print(String.Format("{0}:OnTradeByPctSpd Ex Bip={1}: MaxBip={2}, PosMax={3}, MinBip={4}, PosMin={5}", * CurrentBars[BarsInProgress], BarsInProgress, giPctSpd.PctChgMaxBip, Positions[giPctSpd.PctChgMaxBip], giPctSpd.PctChgMinBip, Positions[giPctSpd.PctChgMinBip])); * OnExitPositions(e); * } else { //entry at 9:02 am ct * Print(String.Format("{0}:OnTradeByPctSpd En Bip={1}: PctSpd={2}, MaxBip={3}, MinBip={4}", * CurrentBar, BarsInProgress, giPctSpd.PlotPctSpd[0], giPctSpd.PctChgMaxBip, giPctSpd.PctChgMinBip)); * if(isig.TrendDir.TrendDir == TrendDirection.Up) { * IndicatorProxy.PrintLog(true, IsLiveTrading(),String.Format("{0}:{1} Ln Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}", * CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0], * q_max, q_min)); * EnterLong(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd"); * EnterShort(giPctSpd.PctChgMinBip, q_min, "GIPctSpd"); * } * else if(isig.TrendDir.TrendDir == TrendDirection.Down) { * IndicatorProxy.PrintLog(true, IsLiveTrading(),String.Format("{0}:{1} St Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}", * CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0], * q_max, q_min)); * EnterShort(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd"); * EnterLong(giPctSpd.PctChgMinBip, q_min, "GIPctSpd"); * } * } */ }
public int HasPosition() { if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, 0); } int pos = 0; if (IsLiveTrading()) { //if(PositionAccount != null) pos = PositionAccount.Quantity; } else //if(Position != null) { pos = Position.Quantity; } return(pos); }
protected override void OnExecutionUpdate(Execution execution, string executionId, double price, int quantity, MarketPosition marketPosition, string orderId, DateTime time) { if (BarsInProgress != 0) { return; } IndicatorProxy.Log2Disk = true; if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBar + ":OnExecutionUpdate" + ";IsUnmanaged=" + IsUnmanaged + ";IsLiveTrading=" + IsLiveTrading() + ";IsInitialEntry=" + execution.IsInitialEntry + ";IsEntry=" + execution.IsEntry + ";IsExit=" + execution.IsExit + ";IsLastExit=" + execution.IsLastExit + ";GetMarketPosition=" + GetMarketPosition() + ";marketPosition=" + marketPosition + ";quantity=" + quantity + ";HasPosition=" + HasPosition() + ";GetAvgPrice=" + GetAvgPrice() + ";price=" + price); } CurrentTrade.OnCurExecutionUpdate(execution, executionId, price, quantity, marketPosition, orderId, time); return; if (IsUnmanaged) { OnExecutionUpdateUM(execution, executionId, price, quantity, marketPosition, orderId, time); } else { OnExecutionUpdateMG(execution, executionId, price, quantity, marketPosition, orderId, time); } }
// Define what actions to take when the event is raised. void OnTradeByPctSpd(object sender, IndicatorEventArgs e) { IndicatorSignal isig = e.IndSignal; Print(String.Format("{0}:OnTradeByPctSpd triggerred {1} Bip{2}: PctSpd={3}, MaxBip={4}, MinBip={5}", CurrentBars[BarsInProgress], isig.SignalName, BarsInProgress, giPctSpd.PlotPctSpd[0], giPctSpd.PctChgMaxBip, giPctSpd.PctChgMinBip)); int q_max = GetTradeQuantity(giPctSpd.PctChgMaxBip, this.MM_ProfitFactorMax); int q_min = GetTradeQuantity(giPctSpd.PctChgMinBip, this.MM_ProfitFactorMin); //exit at 9:40 am ct if (isig.SignalName == giPctSpd.SignalName_ExitForOpen) { Print(String.Format("{0}:OnTradeByPctSpd Ex Bip={1}: MaxBip={2}, PosMax={3}, MinBip={4}, PosMin={5}", CurrentBars[BarsInProgress], BarsInProgress, giPctSpd.PctChgMaxBip, Positions[giPctSpd.PctChgMaxBip], giPctSpd.PctChgMinBip, Positions[giPctSpd.PctChgMinBip])); OnExitPositions(e); } else //entry at 9:02 am ct { Print(String.Format("{0}:OnTradeByPctSpd En Bip={1}: PctSpd={2}, MaxBip={3}, MinBip={4}", CurrentBar, BarsInProgress, giPctSpd.PlotPctSpd[0], giPctSpd.PctChgMaxBip, giPctSpd.PctChgMinBip)); if (isig.TrendDir.TrendDir == TrendDirection.Up) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}:{1} Ln Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}", CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0], q_max, q_min)); EnterLong(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd"); EnterShort(giPctSpd.PctChgMinBip, q_min, "GIPctSpd"); } else if (isig.TrendDir.TrendDir == TrendDirection.Down) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}:{1} St Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}", CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0], q_max, q_min)); EnterShort(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd"); EnterLong(giPctSpd.PctChgMinBip, q_min, "GIPctSpd"); } } }
/// <summary> /// Check if now is the time allowed to put trade /// </summary> /// <param name="time_start">start time</param> /// <param name="time_end">end time</param> /// <param name="session_start">the overnight session start time: 170000 for ES</param> /// <returns></returns> public virtual bool IsTradingTime(int session_start) { //Bars.Session.GetNextBeginEnd(DateTime time, out DateTime sessionBegin, out DateTime sessionEnd) int time_start = IndicatorProxy.GetTimeByHM(TG_TradeStartH, TG_TradeStartM, true); int time_end = IndicatorProxy.GetTimeByHM(TG_TradeEndH, TG_TradeEndM, true); int time_now = ToTime(Time[0]); bool isTime = false; if (time_start >= session_start) { if (time_now >= time_start || time_now <= time_end) { isTime = true; } } else if (time_now >= time_start && time_now <= time_end) { isTime = true; } Print(String.Format("{0}: time_now={1}, session_start={2}, time_start={3}, time_end={4}, isTime={5}", CurrentBar, time_now, session_start, time_start, time_end, isTime)); return(isTime); }
protected override void OnPositionUpdate(Cbi.Position position, double averagePrice, int quantity, Cbi.MarketPosition marketPosition) { IndicatorProxy.Log2Disk = true; int bsx = BarsSinceExitExecution(0, "", 0); int bse = BarsSinceEntryExecution(0, "", 0); if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBar + ":OnPositionUpdate, CurrentTrade not updated -- " + ";BarsSinceExit, BarsSinceEntry=" + bsx + "," + bse + ";IsUnmanaged=" + IsUnmanaged + ";IsLiveTrading=" + IsLiveTrading() + ";GetMarketPosition=" + GetMarketPosition() + ";marketPosition=" + marketPosition + ";HasPosition=" + HasPosition() + ";CurrentTrade.PosQuantity=" + CurrentTrade.PosQuantity + ";CurrentTrade.MktPosition=" + CurrentTrade.MktPosition + ";quantity=" + quantity + ";GetAvgPrice=" + GetAvgPrice() + ";averagePrice=" + averagePrice); } //Print(position.ToString() + "--MarketPosition=" + position.MarketPosition); CurrentTrade.OnCurPositionUpdate(position, averagePrice, quantity, marketPosition); if (CurrentTrade.MktPosition != null && CurrentTrade.PosAvgPrice != null && CurrentTrade.PosQuantity != null && CurrentTrade.PosUnrealizedPnL != null) { if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}: OnPositionUpdate, CurrentTrade updated -- CurrentTrade.PosAvgPrice: {1}, CurrentTrade.PosQuantit={2}, CurrentTrade.MktPosition={3}, PnL={4}", CurrentBar, CurrentTrade.PosAvgPrice, CurrentTrade.PosQuantity, CurrentTrade.MktPosition, CurrentTrade.PosUnrealizedPnL)); } } }
/// <summary> /// The first event handler for each bar; /// Other handlers like OnOrderUpdate, OnExecutionUpdate, OnPositionUpdate, /// are used to setup status for CurrentTrade, the TradeAction will be taken /// on the next bar(CurrentBar+1) at OnBarUpdate; /// The command and performance triggerred TradeAction can be taken at the /// same bar at PutTrade(); /// </summary> protected override void OnBarUpdate() { if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.PrintLog(true, IsLiveTrading(), String.Format("{0}:===========OnBarUpdate======HasPosition={1}, IsLiveTrading={2}", CurrentBar, HasPosition(), IsLiveTrading())); IndicatorProxy.TraceMessage(this.Name, PrintOut); } //Print(CurrentBar.ToString() + " -- GSZTraderBase - Add your custom strategy logic here."); if (CurrentBar <= BarsRequiredToTrade) { return; } int bsx = BarsSinceExitExecution(0, "", 0); int bse = BarsSinceEntryExecution(0, "", 0); SetPrintOut(-1); //Print(CurrentBar + ":" + this.Name + " OnBarUpdate, BarsSinceExit, BarsSinceEntry=" + bsx + "," + bse); if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } IndicatorProxy.Update(); if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } CheckCmd(); //Command trigger switch (AlgoMode) { case AlgoModeType.Liquidate: //liquidate if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } CloseAllPositions(); break; case AlgoModeType.CancelOrders: //cancel order if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } CancelAllOrders(); break; case AlgoModeType.StopTrading: // -2=stop trading(no entry/exit, liquidate positions and cancel all entry/exit orders); CancelAllOrders(); CloseAllPositions(); if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); IndicatorProxy.PrintLog(true, IsLiveTrading(), CurrentBar + "- Stop trading cmd:" + IndicatorProxy.Get24HDateTime(Time[0])); } break; case AlgoModeType.ExitOnly: // -1=stop trading(no entry/exit, cancel entry orders and keep the exit order as it is if there has position); CancelEntryOrders(); break; case AlgoModeType.Trading: //trading //SetTradeAction(); called from CheckExitTrade() or CheckNewEntryTrade(); //CheckIndicatorSignals(); called from SetTradeAction(); save trade signals into the trade action; //PutTrade(); first GetTradeAction() and then put exit or entry trade; if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } //CheckPerformance(); //Performance/Rule trigger //SetTradeAction(); if (HasPosition() != 0) { CheckPerformance(); } //Produce trade signals from indicator indicator signals CheckIndicatorSignals(); //Set trade action replaced by the event hanlder from indicator signals SetTradeAction(); //PutTrade(); TakeTradeAction(); break; case AlgoModeType.SemiAlgo: // 2=semi-algo(manual entry, algo exit); if (HasPosition() != 0) { CheckPerformance(); //Performance/Rule trigger //ChangeSLPT(); //re-implement to fit TradeAction process //Produce trade signals from indicator indicator signals CheckIndicatorSignals(); SetTradeAction(); //PutTrade(); TakeTradeAction(); } break; } if (PrintOut > 1 && !IsInStrategyAnalyzer) { IndicatorProxy.TraceMessage(this.Name, PrintOut); } }