Como faço para pegar o preço de abertura de uma ordem limit ?

[Fernando Paiva]

Estou tentando criar um esquema para realizar ordens parciais mas estou com um problema que depois que abro a primeira ordem, pego o preço de abertura e somo com a quantidade de pontos para abrir o restante das ordens. O problema é que consigo pegar o preço de abertura apenas da primeira ordem, as restantes não consigo, só retorna o preço de abertura da primeira ordem.

Como fazer isso ?

static int setLotesPorOrdem[];
static bool realizouParcial = false;

void realizaEntradaParcial(
                           ulong mn,
                           bool sinalCompra,
                           bool sinalVenda,
                           string lotesPorOrdem,
                           string comment,
                           bool operarCompra,
                           bool operarVenda,
                           double stopLoss,
                           double pontosParcial             
                         ){
    CTrade _trade;
    CSymbolInfo _simbolo;
    _trade.SetExpertMagicNumber(mn);
    _trade.SetTypeFilling(ORDER_FILLING_RETURN);    
            
    double _price = 0;
    double _stopLoss = 0;
    
    if(!_simbolo.Name(_Symbol)){
      PrintFormat("Erro tentando carregar ativo");
      return;
    }
    
    if(!_simbolo.RefreshRates()){
      PrintFormat("Erro tentando executar RefreshRates");
      return;
    }
    
    //define array de lotes
    if(StringLen(lotesPorOrdem) <= 0){
         PrintFormat("Lotes por ordem não informado");
         return;
    }
    
    if(PositionsTotal() == 0){ 
         realizouParcial = false;
         getArrayLotes(lotesPorOrdem);
    }
     
     
    /************************ primeiras ordens *****************/  
    if(PositionsTotal() == 0){
       
       //primeira compra
       if(sinalCompra && operarCompra){
            _price = _simbolo.Ask();
            double _lote = setLotesPorOrdem[0];
            
            if(stopLoss > 0){ 
               if(isDolar()){//verifica se é dolar
                  stopLoss = stopLoss * 1000;
               }                       
               _stopLoss = _simbolo.NormalizePrice(_price - stopLoss * _Point);
            }         
          
            if(!_trade.Buy(_lote, _Symbol, _price, _stopLoss, 0, comment)){
               PrintFormat("Erro envio ordem compra: %d", GetLastError());
               PrintFormat("Retorno do erro: %s", _trade.CheckResultRetcodeDescription());
            }    
          
       }
       //primeira compra
       
       //primeira venda
       if(sinalVenda && operarVenda){
            _price = _simbolo.Bid();
            double _lote = setLotesPorOrdem[0];
            
            if(stopLoss > 0){
               if(isDolar()){ //verifica se é dolar
                  stopLoss = stopLoss * 1000;
               }  
               _stopLoss = _simbolo.NormalizePrice(_price + stopLoss * _Point);
            }        
             
            if(!_trade.Sell(_lote, _Symbol, _price, _stopLoss, 0, comment)){
               PrintFormat("Erro envio ordem venda: %d", GetLastError());
               PrintFormat("Retorno do erro: %s", _trade.CheckResultRetcodeDescription());
               
            }   
       
       }
       //primeira venda
       
       ArrayRemove(setLotesPorOrdem, 0,1); //remove o primeiro lote       
       ArrayResize(setLotesPorOrdem, ArraySize(setLotesPorOrdem)); //redimensiona o array
    
    }
    /************************** close primeiras ordens ********************/
    
    
    
    
    /************************adiciona as parciais *****************/    
    //lanca restante das ordens
    if(PositionsTotal() > 0 && realizouParcial == false){    
    
        for(int i = 0; i < ArraySize(setLotesPorOrdem); i++){ 
                    
               if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY){ //se estiver comprado entao vende parcial
                  double Bid = _simbolo.Bid();
                  
                  double _price = _simbolo.NormalizePrice(getPriceLastOrder(mn) + pontosParcial * _Point);                   
                  if(!_trade.SellLimit(setLotesPorOrdem[i], _price, _Symbol, 0, 0, 0, 0, comment)){
                     Print("Erro tentando realizar parcial de compra: ", GetLastError());
                     Print("Error Description: ", ErrorDescription(GetLastError()));
                  }                
                  
               }
               
               
               if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL){ //se estiver vendido entao compra parcial
                  double Ask = _simbolo.Ask();
                  
                  double _price = _simbolo.NormalizePrice(getPriceLastOrder(mn) - pontosParcial * _Point);                  
                  if(!_trade.BuyLimit(setLotesPorOrdem[i], _price, _Symbol, 0, 0, 0, 0, comment)){
                     Print("Erro tentando realizar parcial de compra: ", GetLastError());
                  }  
                      
               }                  
                             
            
         }//for parcial
        
        realizouParcial = true; //realizou parcial
        //ArrayFree(setLotesPorOrdem); //zera array de lotes
        
    }//lanca restante das ordens    

}//realizaOperacaoParcial




//retorna o preco de abertura da ultima ordem
double getPriceLastOrder(ulong magicNumber){ 
   double _orderOpenPrice = 0;
   
   for(int x = PositionsTotal() -1 ; x >= 0; x--){
         string _symbol = PositionGetSymbol(x);
         ulong _magicNumber = PositionGetInteger(POSITION_MAGIC);  
         ulong _ticket = PositionGetTicket(x);
         
         if(_magicNumber == magicNumber && _Symbol == _symbol){
         
            if((PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) || (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)){
               _orderOpenPrice += PositionGetDouble(POSITION_PRICE_OPEN);
               Print("Ordem Mercado: ");
            }
         
            if((OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_LIMIT) || (OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_LIMIT)){
               _orderOpenPrice += OrderGetDouble(ORDER_PRICE_OPEN);
               Print("Ordem Limite: ");
            }
            break;
         
         }//magic number 
                 
                    
         
        
   }
   
   return _orderOpenPrice;

}