Форум

Подскажите, как правильно использовать представленную ниже функцию при наличии следующих данных.

В системе используются ордера по двум магическим числам, предположим

Magic1=100

Magic2=200

С магическим числом Magic1 могут быть ордера двух типов OP_BUY или OP_BUYSTOP.

С магическим числом Magic2 - OP_SELL или OP_SELLSTOP.

В процессе торгов в рынке могут быть только 3 комбинации ордеров:

3. OrderType() ==OP_BUY и OrderType() == OP_SELL

Далее…

При возникновении комбинации под №3 OrderType() ==OP_BUY и OrderType() == OP_SELL срабатывает функция которая увеличивает абсолютное значение на +1 обоих магиков, в последующем, с поступлением сигналов на покупку или продажу выставляются ордера указанных 3-х комбинаций, но уже с другими значениями магических чисел, пример:

Magic1=1001....

Magic2=2001...

И так далее…

//+------------------------------------------------------------------+
//|                                             AllOrdersControl.mq4 |
//|                                      Copyright © 2006, komposter |
//|                                      mailto:komposterius@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, komposter"
#property link      "mailto:komposterius@mail.ru"
 
// переменная, которая будет хранить количество ордеров, принадлежащих эксперту:
int _ExpertOrdersTotal = 0;
 
// массивы, в которых будут хранитсья характеристики ордеров:
int _OrderTicket[], _OrderType[];
double _OrderLots[], _OrderOpenPrice[], _OrderStopLoss[], _OrderTakeProfit[];
double _OrderProfit[], _OrderSwap[], _OrderCommission[];
datetime _OrderOpenTime[], _OrderExpiration[];
string _OrderComment[];
 
void AllOrdersInit( int magic )
{
    int _GetLastError = 0, _OrdersTotal = OrdersTotal();
    _ExpertOrdersTotal = 0;
 
    // изменяем размеры массивов под текущее кол-во позиций
    // (если _OrdersTotal = 0, меняем размер массивов на 1)
    int temp_value = MathMax( _OrdersTotal, 1 );
    ArrayResize( _OrderTicket,            temp_value );
    ArrayResize( _OrderType,            temp_value );
    ArrayResize( _OrderLots,            temp_value );
    ArrayResize( _OrderOpenPrice,        temp_value );
    ArrayResize( _OrderStopLoss,        temp_value );
    ArrayResize( _OrderTakeProfit,    temp_value );
    ArrayResize( _OrderOpenTime,        temp_value );
    ArrayResize( _OrderProfit,            temp_value );
    ArrayResize( _OrderSwap,            temp_value );
    ArrayResize( _OrderCommission,    temp_value );
    ArrayResize( _OrderComment,        temp_value );
    ArrayResize( _OrderExpiration,    temp_value );
 
    // обнуляем массивы
    ArrayInitialize( _OrderTicket,        0 );
    ArrayInitialize( _OrderType,            0 );
    ArrayInitialize( _OrderLots,            0 );
    ArrayInitialize( _OrderOpenPrice,    0 );
    ArrayInitialize( _OrderStopLoss,        0 );
    ArrayInitialize( _OrderTakeProfit,    0 );
    ArrayInitialize( _OrderOpenTime,        0 );
    ArrayInitialize( _OrderProfit,        0 );
    ArrayInitialize( _OrderSwap,            0 );
    ArrayInitialize( _OrderCommission,    0 );
    ArrayInitialize( _OrderExpiration,    0 );
 
    for ( int z = _OrdersTotal - 1; z >= 0; z -- )
    {
        if ( !OrderSelect( z, SELECT_BY_POS ) )
        {
            _GetLastError = GetLastError();
            Print( "OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError );
            continue;
        }
        if ( OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
        {
            // заполняем массивы
            _OrderTicket        [_ExpertOrdersTotal] = OrderTicket();
            _OrderType            [_ExpertOrdersTotal] = OrderType();
            _OrderLots            [_ExpertOrdersTotal] = NormalizeDouble( OrderLots(), 1 );
            _OrderOpenPrice    [_ExpertOrdersTotal] = NormalizeDouble( OrderOpenPrice(), Digits );
            _OrderStopLoss        [_ExpertOrdersTotal] = NormalizeDouble( OrderStopLoss(), Digits );
            _OrderTakeProfit    [_ExpertOrdersTotal] = NormalizeDouble( OrderTakeProfit(), Digits );
            _OrderOpenTime        [_ExpertOrdersTotal] = OrderOpenTime();
            _OrderProfit        [_ExpertOrdersTotal] = NormalizeDouble( OrderProfit(), 2 );
            _OrderSwap            [_ExpertOrdersTotal] = NormalizeDouble( OrderSwap(), 2 );
            _OrderCommission    [_ExpertOrdersTotal] = NormalizeDouble( OrderCommission(), 2 );
            _OrderComment        [_ExpertOrdersTotal] = OrderComment();
            _OrderExpiration    [_ExpertOrdersTotal] = OrderExpiration();
            _ExpertOrdersTotal ++;
        }
    }
 
    // изменяем размеры массивов под кол-во позиций, принадлежащих эксперту
    // (если _ExpertOrdersTotal = 0, меняем размер массивов на 1)
    temp_value = MathMax( _ExpertOrdersTotal, 1 );
    ArrayResize( _OrderTicket,            temp_value );
    ArrayResize( _OrderType,            temp_value );
    ArrayResize( _OrderLots,            temp_value );
    ArrayResize( _OrderOpenPrice,        temp_value );
    ArrayResize( _OrderStopLoss,        temp_value );
    ArrayResize( _OrderTakeProfit,    temp_value );
    ArrayResize( _OrderOpenTime,        temp_value );
    ArrayResize( _OrderProfit,            temp_value );
    ArrayResize( _OrderSwap,            temp_value );
    ArrayResize( _OrderCommission,    temp_value );
    ArrayResize( _OrderComment,        temp_value );
    ArrayResize( _OrderExpiration,    temp_value );
}

Функция взята из темы статьи: «Управление ордерами – это просто»

'Управление ордерами – это просто'

С уважением, Вячеслав.

// находим ордера с MagicNumber
OneTypeOrdersInit( _MagicNumber );
// если есть хоть одна позиция (или ордер), что-то делаем
if ( _BuyTicket > 0 || _SellTicket > 0 || _BuyStopTicket > 0 || _SellStopTicket > 0 || _BuyLimitTicket > 0 || _SellLimitTicket > 0 )
{
 
 
}
 
// находим ордера с MagicNumber1
OneTypeOrdersInit( _MagicNumber1 );
// и опять, если есть хоть одна позиция (или ордер), что-то делаем
if ( _BuyTicket > 0 || _SellTicket > 0 || _BuyStopTicket > 0 || _SellStopTicket > 0 || _BuyLimitTicket > 0 || _SellLimitTicket > 0 )
{
 
 
}
 
// находим ордера с MagicNumber2
OneTypeOrdersInit( _MagicNumber2 );
if ( _BuyTicket > 0 || _SellTicket > 0 || _BuyStopTicket > 0 || _SellStopTicket > 0 || _BuyLimitTicket > 0 || _SellLimitTicket > 0 )
{
 
 
}

void OneTypeOrdersHist( int magic )
{
// обнуление переменных:
    hBuyTicket = 0; hSellTicket = 0; 
 
    hBuyLots = 0.0; hSellLots = 0.0; 
    
    hBuyOpenPrice = 0.0; hSellOpenPrice = 0.0; 
    
    hBuyStopLoss = 0.0; hSellStopLoss = 0.0; 
 
    hBuyTakeProfit = 0.0; hSellTakeProfit = 0.0;
 
    hBuyOpenTime = -1; hSellOpenTime = -1; 
 
    hBuyProfit = 0.0; hSellProfit = 0.0; 
    
    hBuyOrderCloseTime=-1; hSellOrderCloseTime=-1;
    
    hBuyOrderClosePrice=0.0; hSellOrderClosePrice=0.0;
    
    hBuySwap = 0.0; hSellSwap = 0.0;
    
    hBuyCommission = 0.0; hSellCommission = 0.0;
 
    hBuyComment = ""; hSellComment = ""; 
    
    int Error = 0, Total =  HistoryTotal();
    for ( int i = Total - 1; i >= 0; i -- )
    {
        if ( !OrderSelect(i,SELECT_BY_POS,MODE_HISTORY) )
        {
            Error = GetLastError();
            Print( "OrderSelect( ", i, ", SELECT_BY_POS ) - Error #", Error );
            continue;
        }
        if ( OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
        {
            switch ( OrderType() )
            {
                case OP_BUY:
                    hBuyTicket              = OrderTicket();
                    hBuyLots                  = NormalizeDouble( OrderLots(), 1 );
                    hBuyOpenPrice          = NormalizeDouble( OrderOpenPrice(), Digits );
                    hBuyStopLoss          = NormalizeDouble( OrderStopLoss(), Digits );
                    hBuyTakeProfit          = NormalizeDouble( OrderTakeProfit(), Digits );
                    hBuyOpenTime          = OrderOpenTime();
                    hBuyProfit              = NormalizeDouble( OrderProfit(), 2 );
                    hBuyOrderCloseTime  = OrderCloseTime() ;
                    hBuyOrderClosePrice = NormalizeDouble( OrderClosePrice() ,Digits );
                    hBuySwap                  = NormalizeDouble( OrderSwap(), 2 );
                    hBuyCommission          = NormalizeDouble( OrderCommission(), 2 );
                    hBuyComment              = OrderComment();
                    break;
                case OP_SELL:
                    hSellTicket               = OrderTicket();
                    hSellLots              = NormalizeDouble( OrderLots(), 1 );
                    hSellOpenPrice           = NormalizeDouble( OrderOpenPrice(), Digits );
                    hSellStopLoss           = NormalizeDouble( OrderStopLoss(), Digits );
                    hSellTakeProfit       = NormalizeDouble( OrderTakeProfit(), Digits );
                    hSellOpenTime           = OrderOpenTime();
                    hSellProfit               = NormalizeDouble( OrderProfit(), 2 );
                   hSellOrderCloseTime  = OrderCloseTime() ;
                    hSellOrderClosePrice = NormalizeDouble( OrderClosePrice() , Digits );
                    hSellSwap               = NormalizeDouble( OrderSwap(), 2 );
                    hSellCommission       = NormalizeDouble( OrderCommission(), 2 );
                    hSellComment           = OrderComment();
                    break;
            }
        }
    }
}