public override void onTick(Tick <int> currTick)
{
try
{
spreadAnalyzer.EvaluateSpread(currTick);
ShowComment(currTick);
if (currTime.Ticks / TickHistory.tickInOneMinute == currTick.DateTime.Ticks / TickHistory.tickInOneMinute)
{
return;
}
currTime = currTick.DateTime;
ExtremumPoint.Process(Math.Max(currTick.Bid, Meta.High(this.Symbol, 1)), Math.Min(currTick.Bid, Meta.Low(this.Symbol, 1)), currTick.DateTime);
fluctuationList.Update(ExtremumPoint);
for (int i = fluctuationList.StartIndex; i < fluctuationList.EndIndex; i++)
{
Meta.ObjectMove(GetHLineName(i), 0, DateTime.Now, fluctuationList[i].AveragePrice);
}
if (!strategyTime.IsSystemON(currTick) || newsPeriod.IsNewsTime(currTick.DateTime))
{
OrderOperation.CloseAllOrders();
return;
}
//open/modify tp
AddModifyLimitOrder(fluctuationList.GetHighest(param["OpenOrderPercent"]), param["SL"], fluctuationList.GetHighest(param["TPOrderPercent"]) + spreadAnalyzer.AverageSpread, OrderSide.Sell);
AddModifyLimitOrder(fluctuationList.GetLowest(param["OpenOrderPercent"]) + spreadAnalyzer.AverageSpread, param["SL"], fluctuationList.GetLowest(param["TPOrderPercent"]), OrderSide.Buy);
ModifyMarketOrders(OrderSide.Buy, fluctuationList.GetLowest(param["TPOrderPercent"]));
ModifyMarketOrders(OrderSide.Sell, fluctuationList.GetHighest(param["TPOrderPercent"]) + spreadAnalyzer.AverageSpread);
//close limit orders
//move tp
// //check condition to close order
//int sign = fluctuationList.GetSignDistanceFromAverageInPercent(currTick.Bid);
//if (sign >= 0)
// CloseOrders(OrderSide.Buy, marketOrders);
//if (sign <= 0)
// CloseOrders(OrderSide.Sell, marketOrders);
//int peakDistanceFromAverageMinAbs = fluctuationList.GetMinDistanceFromAverageInPercent(currTick.Bid);
//if (Math.Abs(peakDistanceFromAverageMinAbs) > param["OpenOrderPercent"])
// OpenNewMarketOrder(peakDistanceFromAverageMinAbs < 0 ? OrderSide.Buy : OrderSide.Sell, marketOrders, currTick);
}
catch (HistoryNotAvailableExceptions exc)
{
return;
}
}
public override void onTick(Tick <int> currTick)
{
spreadAnalyzer.EvaluateSpread(currTick);
ShowComment(currTick);
if (currTime.Ticks / TickHistory.tickInOneMinute == currTick.DateTime.Ticks / TickHistory.tickInOneMinute)
{
return;
}
currTime = currTick.DateTime;
int orderID = Meta.OrderSend(base.Symbol, OrderType.Market, OrderSide.Buy, 100, currTick.Ask, 0, 0, "");
Meta.OrderClose(orderID, 100, currTick.Bid, 0);
}
public override void onTick(Tick <int> currTick)
{
lock (sObject)
{
try
{
base.InitComment();
if (!this.TestingMode)
{
spreadAnalyzer.EvaluateSpread(currTick);
}
if (currTime.Ticks / (TickHistory.tickInOneMinute) == currTick.DateTime.Ticks / (TickHistory.tickInOneMinute))
{
return;
}
currTime = currTick.DateTime;
foreach (BuyLimitAndWaitParam cparam in customParams)
{
if (cparam.InitHistoryMinutes > 0)
{
cparam.historySimulator = new HistorySimulator(cparam, base.TestingMode, new BuyLimitAndWaitStrategy(), this.param, cparam.Symbol, this.Meta);
if (TestingMode)
{
cparam.StartDate = currTick.DateTime.AddMinutes(-cparam.InitHistoryMinutes);
}
List <string> logString;
base.AddComment(cparam.ID, string.Format("Start simulate from {0} to {1}\n", cparam.StartDate.ToShortDateString(), currTick.DateTime.ToShortDateString()));
IEnumerable <Order> newOrders = cparam.historySimulator.Init(currTick.DateTime, cparam.StartDate, out logString);
if (cparam.historySimulator.IsSuccessful)
{
base.AddComment(cparam.ID, "Simulation was successful");
if (TestingMode)
{
Tick <int> currSymbolTick = new Tick <int>();
currSymbolTick.Ask = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_ASK);
currSymbolTick.Bid = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_BID);
currSymbolTick.DateTime = currTick.DateTime;
currSymbolTick.volume = 1;
AddOrders(currSymbolTick, newOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment)));
}
}
else
{
base.AddComment(cparam.ID, "History Simulator return error. Init state is not valid.\n");
}
cparam.InitHistoryMinutes = 0;
}
}
IEnumerable <Order> allBuyOrders = OrderOperation.GetBuyMarketOrders();
IEnumerable <Order> allSellOrders = OrderOperation.GetSellMarketOrders();
IEnumerable <Order> allBuyLimitOrders;
IEnumerable <Order> allSellLimitOrders;
if (!TestingMode)
{
PositionAggregator pa = new PositionAggregator();
foreach (BuyLimitAndWaitParam cparam in customParams)
{
Tick <int> currSymbolTick = new Tick <int>();
currSymbolTick.Ask = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_ASK);
currSymbolTick.Bid = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_BID);
currSymbolTick.DateTime = currTick.DateTime;
currSymbolTick.volume = 1;
IEnumerable <Order> requiredOrders = cparam.historySimulator.AddTick(currSymbolTick);
//IEnumerable<Order> openedOrders = allBuyOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment))
// .Union(allSellOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment)));
pa.AddRequrementPosition(requiredOrders);
base.AddCommentLine(cparam.Symbol, string.Format("{0} - openPrices={1}, tpPrices={2}",
currSymbolTick.DateTime.ToShortTimeString(),
String.Join(", ", cparam.historySimulator.LimitOrders.Select(p => p.OpenPrice)),
String.Join(", ", cparam.historySimulator.MarketOrders.Select(p => p.TP))
));
}
foreach (BuyLimitAndWaitParam cparam in customParams)
{
pa.CheckMinTradeVolumeSize(cparam.Symbol, cparam.MinTradeVolume);
}
pa.AddCurrentPositions(allBuyOrders);
pa.AddCurrentPositions(allSellOrders);
foreach (KeyValuePair <string, int> kv in pa.ResultDiff.Where(p => p.Value != 0))
{
Tick <int> currSymbolTick = new Tick <int>();
currSymbolTick.Ask = Meta.MarketInfo(kv.Key, MarketInfoType.MODE_ASK);
currSymbolTick.Bid = Meta.MarketInfo(kv.Key, MarketInfoType.MODE_BID);
currSymbolTick.DateTime = currTick.DateTime;
currSymbolTick.volume = 1;
AddComment(string.Format("Adding new order for symbol {0} with volume {1}", kv.Key, kv.Value));
Meta.OrderSend(kv.Key, OrderType.Market, kv.Value > 0 ? OrderSide.Buy : OrderSide.Sell, Math.Abs(kv.Value),
kv.Value > 0 ? currSymbolTick.Ask : currSymbolTick.Bid, 0, 0, "");
}
allBuyOrders = OrderOperation.GetBuyMarketOrders();
allSellOrders = OrderOperation.GetSellMarketOrders();
var elem = allBuyOrders.Join(allSellOrders, bO => bO.Symbol, sO => sO.Symbol, (bO, sO) => new { t1 = bO.ID, t2 = sO.ID }).FirstOrDefault();
if (elem != null)
{
AddComment(string.Format("Trying to close by two orders: {0} and {1}.", elem.t1, elem.t2));
Meta.OrderCloseBy(elem.t1, elem.t2, 0);
AddComment(string.Format("Successfull close by two orders: {0} and {1}.", elem.t1, elem.t2));
}
return;
}
BuyLimitAndWaitParam firstParam = customParams[0];
RemoveAllLimitWithoutPair(OrderOperation.GetBuyLimitOrders(), OrderOperation.GetSellLimitOrders(),
firstParam, currTick);
allBuyLimitOrders = OrderOperation.GetBuyLimitOrders();
allSellLimitOrders = OrderOperation.GetSellLimitOrders();
Order minBuyOrder = null;
Order maxSellOrder = null;
if (allBuyOrders != null)
{
minBuyOrder = allBuyOrders
.Where(p => p.Comment.StartsWith(firstParam.IdentityComment))
//.MinElement(p => p.OpenPrice);
.MinElement(p => p.TP);
}
if (allSellOrders != null)
{
maxSellOrder = allSellOrders
.Where(p => p.Comment.StartsWith(firstParam.IdentityComment))
//.MaxElement(p => p.OpenPrice);
.MaxElement(p => p.TP);
}
bool isLimitExist = allSellLimitOrders.Where(p => p.Comment.StartsWith(firstParam.IdentityComment)).Count() != 0 ||
allBuyLimitOrders.Where(p => p.Comment.StartsWith(firstParam.IdentityComment)).Count() != 0;
if (this.TestingMode && minBuyOrder != null && !isLimitExist)
{
RegisterTickToHandle.RegisterBuyLimit((minBuyOrder.TP - 2 * firstParam.TP) - firstParam.OpenOrderShift);
}
if (this.TestingMode && maxSellOrder != null && !isLimitExist)
{
RegisterTickToHandle.RegisterSellLimit(firstParam.OpenOrderShift + (maxSellOrder.TP + 2 * firstParam.TP));
}
if (!isLimitExist &&
//(minBuyOrder != null && minBuyOrder.OpenPrice - currSymbolTick.Ask > firstParam.OpenOrderShift
//|| maxSellOrder != null && currSymbolTick.Bid - maxSellOrder.OpenPrice > firstParam.OpenOrderShift
(minBuyOrder != null && (minBuyOrder.TP - 2 * firstParam.TP) - currTick.Ask >= firstParam.OpenOrderShift ||
maxSellOrder != null && currTick.Bid - (maxSellOrder.TP + 2 * firstParam.TP) >= firstParam.OpenOrderShift ||
minBuyOrder == null && maxSellOrder == null)
)
{
string comment = firstParam.NewUniqueComment();
int openPrice = currTick.Ask - firstParam.TP;
if (firstParam.OpenMode != OpenMode.OnlySell &&
(minBuyOrder == null || (minBuyOrder.TP - 2 * firstParam.TP) - openPrice >= firstParam.OpenOrderShift))
{
int buyOrderID = Meta.OrderSend(firstParam.Symbol, OrderType.Limit, OrderSide.Buy, firstParam.BasicVolume, openPrice, 0, openPrice + 2 * firstParam.TP, comment);
if (buyOrderID <= 0)
{
Meta.Print(string.Format("Error of adding buy order. Price = {0} Symbol = {1}", openPrice, firstParam.Symbol));
Meta.Comment(string.Format("Error of adding buy order. Price = {0} Symbol = {1}", openPrice, firstParam.Symbol));
return;
}
this.RegisterTickToHandle.RegisterBuyStop(openPrice + 2 * firstParam.TP);
}
openPrice = currTick.Bid + firstParam.TP;
if (firstParam.OpenMode != OpenMode.OnlyBuy &&
(maxSellOrder == null || openPrice - (maxSellOrder.TP + 2 * firstParam.TP) >= firstParam.OpenOrderShift))
{
int sellOrderID = Meta.OrderSend(firstParam.Symbol, OrderType.Limit, OrderSide.Sell, firstParam.BasicVolume, openPrice, 0, openPrice - 2 * firstParam.TP, comment);
if (sellOrderID <= 0)
{
Meta.Print(string.Format("Error of adding sell order. Price = {0} Symbol = {1}", openPrice, firstParam.Symbol));
Meta.Comment(string.Format("Error of adding sell order. Price = {0} Symbol = {1}", openPrice, firstParam.Symbol));
}
this.RegisterTickToHandle.RegisterSellStop(openPrice - 2 * firstParam.TP);
}
}
}
catch (HistoryNotAvailableExceptions exc)
{
logger.AddMessage("tick = {0}\r\n {1}", currTick.DateTime.ToLongTimeString(), exc);
throw;
}
finally
{
ShowComment();
}
}
}
public override void onTick(Tick <int> currTick)
{
try
{
spreadAnalyzer.EvaluateSpread(currTick);
ShowComment(currTick);
if (!strategyTime.IsSystemON(currTick))
{
martinStep = 0;
OrderOperation.CloseAllOrders();
return;
}
if (martinStep < 99999)
{
if (virtualLastMarketOpenPrice == 0)
{
virtualLastMarketOpenPrice = currTick.Ask;
Meta.Print("New wave was started. virtualLastMarketOpenPrice = " + virtualLastMarketOpenPrice.ToString() + ", virtualBuySide = " + virtualBuySide.ToString());
return;
}
if (virtualBuySide)//BUY
{
if (currTick.Bid >= virtualLastMarketOpenPrice + param["TP"])
{
Meta.Print("TP was hitted. martinStep was " + martinStep.ToString());
virtualLastMarketOpenPrice = 0;
martinStep = 0;
return;
}
if (currTick.Bid <= virtualLastMarketOpenPrice - param["BuySellDistance"])
{
virtualLastMarketOpenPrice = currTick.Bid;
martinStep++;
virtualBuySide = !virtualBuySide;
Meta.Print(string.Format("New order should be open. VirtualBuySide = {2}, VirtualLastMarketOpenPrice = {0}, marginStep = {1}."
, virtualLastMarketOpenPrice, martinStep, virtualBuySide));
if (martinStep >= param["StartStep"])
{
Meta.OrderSend(base.Symbol, OrderType.Market, OrderSide.Buy, GetVolumeForStep(martinStep), currTick.Ask, 0, 0, "");
ModifyMarketOrders(OrderSide.Buy, currTick.Ask + param["TP"], 0);
ModifyMarketOrders(OrderSide.Sell, 0, currTick.Ask + param["TP"]);
}
}
}
else //SELL
{
if (currTick.Ask <= virtualLastMarketOpenPrice - param["TP"])
{
Meta.Print("TP was hitted. martinStep was " + martinStep.ToString());
virtualLastMarketOpenPrice = 0;
martinStep = 0;
return;
}
if (currTick.Ask >= virtualLastMarketOpenPrice + param["BuySellDistance"])
{
virtualLastMarketOpenPrice = currTick.Ask;
martinStep++;
virtualBuySide = !virtualBuySide;
Meta.Print(string.Format("New order should be open. VirtualBuySide = {2}, VirtualLastMarketOpenPrice = {0}, marginStep = {1}."
, virtualLastMarketOpenPrice, martinStep, virtualBuySide));
if (martinStep >= param["StartStep"])
{
Meta.OrderSend(base.Symbol, OrderType.Market, OrderSide.Sell, GetVolumeForStep(martinStep), currTick.Bid, 0, 0, "");
ModifyMarketOrders(OrderSide.Sell, currTick.Bid - param["TP"], 0);
ModifyMarketOrders(OrderSide.Buy, 0, currTick.Bid - param["TP"]);
}
}
}
return;
}
}
catch (HistoryNotAvailableExceptions exc)
{
return;
}
}
public override void onTick(Tick <int> currTick)
{
try
{
spreadAnalyzer.EvaluateSpread(currTick);
ShowComment(currTick);
if (currTime.Ticks / TickHistory.tickInOneMinute == currTick.DateTime.Ticks / TickHistory.tickInOneMinute)
{
return;
}
currTime = currTick.DateTime;
//foreach (BuyLimitAndWaitParam cparam in customParams)
//{
// if (cparam.InitHistoryMinutes > 0)
// {
// if (this.OrderOperation.GetLimitOrders().Where(p => p.Comment.StartsWith(cparam.IdentityComment)).Count() > 0
// || this.OrderOperation.GetMarketOrders().Where(p => p.Comment.StartsWith(cparam.IdentityComment)).Count() > 0
// )
// {
// cparam.InitHistoryMinutes = 0;
// continue;
// }
// List<string> logString;
// IEnumerable<Order> newOrders = new HistorySimulator(cparam, base.TestingMode).Run(new BuyAndWaitStrategy(),
// currTick.DateTime, out logString, this.param, cparam.Symbol);
// AddOrders(currTick, newOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment)));
// cparam.InitHistoryMinutes = 0;
// }
//}
//EURUSD, GBPUSD, GBPCHF, EURCHF, CADJPY, AUDJPY, AUDNZD
IEnumerable <Order> allBuyOrders = OrderOperation.GetBuyMarketOrders();
IEnumerable <Order> allSellOrders = OrderOperation.GetSellMarketOrders();
foreach (BuyLimitAndWaitParam cparam in customParams)
{
Tick <int> currSymbolTick = new Tick <int>();
currSymbolTick.Ask = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_ASK);
currSymbolTick.Bid = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_BID);
currSymbolTick.DateTime = currTick.DateTime;
currSymbolTick.volume = 1;
Order minBuyOrder = null;
Order maxSellOrder = null;
if (allBuyOrders != null)
{
minBuyOrder = allBuyOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment)).MinElement(p => p.OpenPrice);
}
if (allSellOrders != null)
{
maxSellOrder = allSellOrders.Where(p => p.Comment.StartsWith(cparam.IdentityComment)).MaxElement(p => p.OpenPrice);
}
if (minBuyOrder != null && minBuyOrder.OpenPrice - currSymbolTick.Ask > cparam.OpenOrderShift ||
maxSellOrder != null && currSymbolTick.Bid - maxSellOrder.OpenPrice > cparam.OpenOrderShift ||
minBuyOrder == null && maxSellOrder == null)
{
string comment = cparam.NewUniqueComment();
int buyOrderID = Meta.OrderSend(cparam.Symbol, OrderType.Market, OrderSide.Buy, cparam.BasicVolume, currSymbolTick.Ask, 0, 0, comment);
if (buyOrderID <= 0)
{
continue;
}
int sellOrderID;
do
{
sellOrderID = Meta.OrderSend(cparam.Symbol, OrderType.Market, OrderSide.Sell, cparam.BasicVolume, currSymbolTick.Bid, 0, 0, comment);
if (sellOrderID <= 0)
{
Meta.Print("Error of adding sell order. Trying to send again.");
Meta.Comment("Error of adding sell order. Trying to send again.");
}
} while (sellOrderID <= 0);
ModifyMarketOrders(OrderSide.Buy, currSymbolTick.Ask + cparam.TP, comment, cparam.Symbol);
ModifyMarketOrders(OrderSide.Sell, currSymbolTick.Bid - cparam.TP, comment, cparam.Symbol);
}
if (TralTP > 0)
{
//trailing tp
foreach (Order currOrder in allBuyOrders)
{
if (currOrder.TP - currSymbolTick.Bid > TralTP)
{
Meta.OrderModify(currOrder.ID, currOrder.OpenPrice, currOrder.SL, currSymbolTick.Bid + TralTP, currOrder.Type);
}
}
foreach (Order currOrder in allSellOrders)
{
if (currSymbolTick.Ask - currOrder.TP > TralTP)
{
Meta.OrderModify(currOrder.ID, currOrder.OpenPrice, currOrder.SL, currSymbolTick.Ask - TralTP, currOrder.Type);
}
}
}
}
}
catch (HistoryNotAvailableExceptions exc)
{
return;
}
}
//internal void InitExtremum(int AmountBars)
//{
// ExtremumPoints.Min = Math.Max(Meta.Open(this.Symbol, AmountBars), Meta.High(this.Symbol, AmountBars + 1)); ;
// ExtremumPoints.Max = Math.Min(Meta.Open(this.Symbol, AmountBars), Meta.Low(this.Symbol, AmountBars + 1));
// for (int i = AmountBars; i >= 1; i--)
// ExtremumPoints.Process(Math.Max(Meta.Open(this.Symbol, i), Meta.High(this.Symbol, i + 1)), Math.Min(Meta.Open(this.Symbol, i), Meta.Low(this.Symbol, i + 1)));
//}
public override void onTick(Tick <int> currTick)
{
try
{
spreadAnalyzer.EvaluateSpread(currTick);
InitComment();
if ((currTick.DateTime.DayOfWeek == DayOfWeek.Friday && currTick.DateTime.Hour > 23) ||
(currTick.DateTime.DayOfWeek == DayOfWeek.Monday && currTick.DateTime.Hour < 1))
{
this.OrderOperation.CloseAllOrders();
return;
}
for (int i = 0; i < customParams.Count; i++)
{
AddComment(() => string.Format("{0}; {1}\n", customParams[i].Symbol, ExtremumPoints[i].ToString()));
MartinGaleParam cparam = customParams[i];
Tick <int> currSymbolTick = new Tick <int>
{
Ask = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_ASK),
Bid = Meta.MarketInfo(cparam.Symbol, MarketInfoType.MODE_BID),
DateTime = currTick.DateTime,
volume = 1
};
IEnumerable <Order> allBuyOrders = OrderOperation.GetBuyMarketOrders()
.Where(p => p.Comment.StartsWith(cparam.IdentityComment));
IEnumerable <Order> allSellOrders = OrderOperation.GetSellMarketOrders()
.Where(p => p.Comment.StartsWith(cparam.IdentityComment));
if (allBuyOrders.Any() && ExtremumPoints[i].FlagUP)
{
Meta.Print("Closing all buy orders");
CloseOrders(allBuyOrders);
}
if (allSellOrders.Any() && !ExtremumPoints[i].FlagUP)
{
Meta.Print("Closing all sell orders");
CloseOrders(allSellOrders);
}
if (!ExtremumPoints[i].FlagUP)
{
int shift = (ExtremumPoints[i].Max - currSymbolTick.Bid);
AddComment(() => "Current Shift = " + shift);
int summOpenVolume = allBuyOrders.Sum(p => p.Volume);
int step = CalculateCurrentStep(cparam, shift, 0);
int reqVolume = GetVolumeByStep(cparam, step);
AddComment(() => " Required Volume = " + reqVolume + "\n\n");
if (IsMaximumExceeded(cparam, shift))
{
CloseOrders(allBuyOrders);
}
else if (step == 1 || (step > 1 && allBuyOrders.Any()))
{
TryToOpenCorrectVolume(OrderSide.Buy, reqVolume - summOpenVolume, cparam);
}
}//FLagUP
else
{
int shift = (currSymbolTick.Bid - ExtremumPoints[i].Min);
AddComment(() => "Current Shift = " + shift.ToString());
int summOpenVolume = allSellOrders.Sum(p => p.Volume);
int step = CalculateCurrentStep(cparam, shift, 0);
int reqVolume = GetVolumeByStep(cparam, step);
AddComment(delegate { return(" Required Volume = " + reqVolume.ToString() + "\n\n"); });
if (IsMaximumExceeded(cparam, shift))
{
CloseOrders(allSellOrders);
}
else if (step == 1 || (step > 1 && allSellOrders.Any()))
{
TryToOpenCorrectVolume(OrderSide.Sell, reqVolume - summOpenVolume, cparam);
}
}
}
}
catch (HistoryNotAvailableExceptions exc)
{
Meta.Print("HistoryNotAvailableExceptions exc");
return;
}
finally
{
ShowComment();
}
}
public override void onTick(Tick <int> currTick)
{
Spread = spreadAnalyzer.EvaluateSpread(currTick);
ExtremumPoint.Process(Math.Max(currTick.Bid, Meta.High(this.Symbol, 1)), Math.Min(currTick.Bid, Meta.Low(this.Symbol, 1)), currTick.DateTime);
ExtremumPoint2.Process(Math.Max(currTick.Bid, Meta.High(this.Symbol, 1)), Math.Min(currTick.Bid, Meta.Low(this.Symbol, 1)), currTick.DateTime);
if (currTime.Ticks / TickHistory.tickInOneMinute == currTick.DateTime.Ticks / TickHistory.tickInOneMinute)
{
return;
}
currTime = currTick.DateTime;
if (!TestingMode)
{
ShowComment();
}
try
{
int PriceBidHighest = Math.Max(currTick.Bid, Meta.High(this.Symbol, 1));
int PriceBidLowest = Math.Min(currTick.Bid, Meta.Low(this.Symbol, 1));
int PriceAskHighest = PriceBidHighest + Spread;
int PriceAskLowest = PriceBidLowest + Spread;
IEnumerable <Order> marketOrders = this.OrderOperation.GetMarketOrders();
IEnumerable <Order> limitOrders = this.OrderOperation.GetLimitOrders();
foreach (Order currOrder in marketOrders)
{
if (currOrder.Side == OrderSide.Buy)
{
if (currOrder.TP - PriceAskLowest > param["TP"])
{
OrderOperation.ModifyMarketOrder(currOrder.ID, currOrder.SL, PriceAskLowest + param["TP"]);
}
}
else
{
if (PriceBidHighest - currOrder.TP > param["TP"])
{
OrderOperation.ModifyMarketOrder(currOrder.ID, currOrder.SL, PriceBidHighest - param["TP"]);
}
}
}
foreach (Order currOrder in limitOrders)
{
if (!strategyTime.IsSystemON(currTick))
{
OrderOperation.CloseOrder(currOrder);
break;
}
if (currOrder.Side == OrderSide.Buy)
{
if (PriceAskHighest - currOrder.OpenPrice > param["LimitOpen"])
{
int openPrice = PriceAskHighest - param["LimitOpen"];
OrderOperation.ModifyLimitOrder(currOrder.ID, openPrice, openPrice - param["SL"], openPrice + param["TP"]);
}
if (!ExtremumPoint.FlagUP)
{
OrderOperation.CloseOrder(currOrder);
}
}
else
{
if (currOrder.OpenPrice - PriceBidLowest > param["LimitOpen"])
{
int openPrice = PriceBidLowest + param["LimitOpen"];
OrderOperation.ModifyLimitOrder(currOrder.ID, openPrice, openPrice + param["SL"], openPrice - param["TP"]);
}
if (ExtremumPoint.FlagUP)
{
OrderOperation.CloseOrder(currOrder);
}
}
}
if (strategyTime.IsSystemON(currTick) && limitOrders.Count() == 0 && marketOrders.Count() == 0)
{
if (ExtremumPoint2.FlagUP == ExtremumPoint.FlagUP)
{
OrderSide side = ExtremumPoint.FlagUP ? OrderSide.Buy : OrderSide.Sell;
int openPrice = side == OrderSide.Buy ? PriceAskHighest - param["LimitOpen"] : PriceBidLowest + param["LimitOpen"];
OrderOperation.AddOrder(Order.NewLimitOrder(Meta.Symbol(), side, GetVolume(), openPrice, param["SL"], param["TP"]));
}
}
}
catch (Exception exc)
{
logger.AddMessage(exc.ToString());
}
}
