Biblioteca para desenvolvimento fácil e rápido de programas para a MetaTrader (parte II). Coleção do histórico de ordens e negócios
1 879
0
Conteúdo
- Objetos do histórico de ordens e negócios
- Coleção do histórico de ordens e negócios
- Qual é o próximo?
No artigo anterior, nós começamos a criar uma grande biblioteca multi-plataforma simplificando o desenvolvimento de programas para as plataformas MetaTrader 5 e MetaTrader 4. Nós criamos o objeto abstrato COrder, que é um objeto base para o armazenamento de dados do histórico de ordens e negócios, bem como as ordens à mercado e posições.
Nesta parte, nós continuaremos o desenvolvimento de todos os objetos necessários para armazenar os dados do histórico da conta em coleções, preparar a coleção do histórico de ordens e negócios, bem como modificar e melhorar os objetos e enumerações já criados.
Objetos do histórico de ordens e negócios
O objeto base COrder contém todos os dados de qualquer objeto da conta, seja uma ordem à mercado (uma ordem para executar uma ação), uma ordem pendente, um negócio ou uma posição. Para que possamos operar livremente todos esses objetos separadamente, nós desenvolveremos várias classes baseadas na classe abstrata COrder. Essas classes indicarão com precisão a afiliação do objeto ao seu tipo.
A lista do histórico de ordens e negócios pode apresentar vários tipos de tais objetos: ordem pendente removida, ordem á mercado colocada e negócio (resultado da execução da ordem à mercado). Existem também mais dois tipos de objetos em MQL4: operações de saldo e crédito (em MQL5, esses dados são armazenados nas propriedades de negócio).
Crie a nova classe CHistoryOrder na pasta Objects da biblioteca.
Para fazer isso, clique com o botão direito do mouse na pasta Objects e selecione o item do menu "Novo arquivo" (Ctrl+N). No Assistente MQL5 recém-aberto, selecione "Nova Classe" e clique em Próximo. Digite CHistoryOrder (1) no campo nome da classe, especifique o nome da classe abstrata COrder(2) no campo da classe base e clique em Concluir.
Depois disso, o arquivo HistoryOrder.mqh (3) é gerado na pasta Objects. Abra-o:
//+------------------------------------------------------------------+ //| HistoryOrder.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CHistoryOrder : public COrder { private: public: CHistoryOrder(); ~CHistoryOrder(); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryOrder::CHistoryOrder() { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryOrder::~CHistoryOrder() { } //+------------------------------------------------------------------+
Por enquanto, isso é apenas um modelo de classe. Se nós tentarmos compilá-lo, nós veremos os cinco erros já conhecidos — a nova classe derivada de COrder não sabe nada sobre o seu pai. Adicione o arquivo de inclusão Order.mqh:
//+------------------------------------------------------------------+ //| HistoryOrder.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include "Order.mqh" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CHistoryOrder : public COrder { private: public: CHistoryOrder(); ~CHistoryOrder(); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryOrder::CHistoryOrder() { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryOrder::~CHistoryOrder() { } //+------------------------------------------------------------------+
Agora todo o código é compilado sem problemas.
A classe será bem pequena. Nós precisamos redefinir os métodos da classe pai COrder, que retornam as flags de manutenção das propriedades da ordem, bem como definir a passagem do ticket da ordem para a classe no construtor:
//+------------------------------------------------------------------+ //| HistoryOrder.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include "Order.mqh" //+------------------------------------------------------------------+ //| Histórico de ordens à mercado | //+------------------------------------------------------------------+ class CHistoryOrder : public COrder { public: //--- Construtor CHistoryOrder(const ulong ticket) : COrder(ORDER_STATUS_HISTORY_ORDER,ticket) {} //--- Propriedades da ordem do tipo inteiro suportadas virtual bool SupportProperty(ENUM_ORDER_PROP_INTEGER property); }; //+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryOrder::SupportProperty(ENUM_ORDER_PROP_INTEGER property) { if(property==ORDER_PROP_TIME_EXP || property==ORDER_PROP_DEAL_ENTRY || property==ORDER_PROP_TIME_UPDATE || property==ORDER_PROP_TIME_UPDATE_MSC ) return false; return true; } //+------------------------------------------------------------------+
Assim, um ticket de uma ordem selecionada é passada para o construtor de classe, enquanto o estado da ordem (histórico da ordem) e seu ticket são passados para o construtor protegido do objeto pai COrder.
Nós também redefinimos o método virtual de suporte ao retorno da classe pai para as propriedades do tipo inteiro de ordem. Os métodos que retornam o suporte para as propriedades do tipo real e string da ordem foram deixados inalterados — esses métodos da classe pai sempre retornam 'true' e nós assumimos que o histórico da ordem suporta todas as propriedades do tipo real e string, portanto nós não redefiniremos ela ainda.
Verifica a propriedade no método que suporta as propriedades do tipo inteiro da ordem. Se esta é o tempo de expiração, direção do negócio ou alteração do horário da posição, retorna 'false'. Tais propriedades não são suportadas pelas ordens à mercado. Todas as propriedades restantes são suportadas e retornado 'true'.
De maneira semelhante, crie a classe CHistoryPending do histórico de ordens pendentes (removida) e a classe CHistoryDeal do histórico de negócios:
//+------------------------------------------------------------------+ //| HistoryPending.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include "Order.mqh" //+------------------------------------------------------------------+ //| Ordem pendente removida | //+------------------------------------------------------------------+ class CHistoryPending : public COrder { public: //--- Construtor CHistoryPending(const ulong ticket) : COrder(ORDER_STATUS_HISTORY_PENDING,ticket) {} //--- Propriedades das ordens suportadas do tipo (1) real, (2) inteiro virtual bool SupportProperty(ENUM_ORDER_PROP_DOUBLE property); virtual bool SupportProperty(ENUM_ORDER_PROP_INTEGER property); }; //+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryPending::SupportProperty(ENUM_ORDER_PROP_INTEGER property) { if(property==ORDER_PROP_PROFIT_PT || property==ORDER_PROP_DEAL_ORDER || property==ORDER_PROP_DEAL_ENTRY || property==ORDER_PROP_TIME_UPDATE || property==ORDER_PROP_TIME_UPDATE_MSC || property==ORDER_PROP_TICKET_FROM || property==ORDER_PROP_TICKET_TO || property==ORDER_PROP_CLOSE_BY_SL || property==ORDER_PROP_CLOSE_BY_TP ) return false; return true; } //+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryPending::SupportProperty(ENUM_ORDER_PROP_DOUBLE property) { if(property==ORDER_PROP_COMMISSION || property==ORDER_PROP_SWAP || property==ORDER_PROP_PROFIT || property==ORDER_PROP_PROFIT_FULL || property==ORDER_PROP_PRICE_CLOSE ) return false; return true; } //+------------------------------------------------------------------+
//+------------------------------------------------------------------+ //| HistoryDeal.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include "Order.mqh" //+------------------------------------------------------------------+ //| Histórico de negócios | //+------------------------------------------------------------------+ class CHistoryDeal : public COrder { public: //--- Construtor CHistoryDeal(const ulong ticket) : COrder(ORDER_STATUS_DEAL,ticket) {} //--- Propriedades dos negócios suportados do tipo (1) real, (2) inteiro virtual bool SupportProperty(ENUM_ORDER_PROP_DOUBLE property); virtual bool SupportProperty(ENUM_ORDER_PROP_INTEGER property); }; //+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryDeal::SupportProperty(ENUM_ORDER_PROP_INTEGER property) { if(property==ORDER_PROP_TIME_EXP || property==ORDER_PROP_PROFIT_PT || property==ORDER_PROP_POSITION_BY_ID || property==ORDER_PROP_TIME_UPDATE || property==ORDER_PROP_TIME_UPDATE_MSC || property==ORDER_PROP_STATE || ( this.OrderType()==DEAL_TYPE_BALANCE && ( property==ORDER_PROP_POSITION_ID || property==ORDER_PROP_POSITION_BY_ID || property==ORDER_PROP_TICKET_FROM || property==ORDER_PROP_TICKET_TO || property==ORDER_PROP_DEAL_ORDER || property==ORDER_PROP_MAGIC || property==ORDER_PROP_TIME_CLOSE || property==ORDER_PROP_TIME_CLOSE_MSC || property==ORDER_PROP_CLOSE_BY_SL || property==ORDER_PROP_CLOSE_BY_TP ) ) ) return false; return true; } //+------------------------------------------------------------------+ bool CHistoryDeal::SupportProperty(ENUM_ORDER_PROP_DOUBLE property) { if(property==ORDER_PROP_TP || property==ORDER_PROP_SL || property==ORDER_PROP_PRICE_CLOSE || property==ORDER_PROP_VOLUME_CURRENT || property==ORDER_PROP_PRICE_STOP_LIMIT || ( this.OrderType()==DEAL_TYPE_BALANCE && ( property==ORDER_PROP_PRICE_OPEN || property==ORDER_PROP_COMMISSION || property==ORDER_PROP_SWAP || property==ORDER_PROP_VOLUME ) ) ) return false; return true; } //+------------------------------------------------------------------+
Nós criamos três objetos order para os quais a coleção do histórico de ordens deve se basear. Todos eles são herdados da classe base e abstrata COrder. Eles têm suas propriedades, mas permitem retornar apenas as propriedades suportadas por esse tipo de ordem. Todos eles devem estar localizados em uma única lista de coleção (coleção do histórico de ordens), a partir da qual nós vamos receber todos os dados necessários sobre o histórico da conta em qualquer composição e ordem.
Nem todas as propriedades suportadas ou não suportadas são consideradas nos métodos SupportProperty() para exibir as propriedades da ordem no diário. Por exemplo, apenas três tipos são considerados para os negócios: operações de compra, venda e saldo.
As propriedades que ainda não foram consideradas e especificadas explicitamente nos métodos que retornam o suporte para elas sempre serão impressas. Em seguida, você pode adicioná-los ao método para não imprimir as propriedades que sempre retornam valores iguais a zero, independentemente da situação (sem suporte).Coleção do histórico de ordens e negócios
É sempre útil ter o histórico da conta em mãos. O terminal fornece e provê as ferramentas para obtê-lo nos programas. No entanto, nossas tarefas atuais exigem uma lista personalizada que nós podemos ordenar e reorganizar para retornar os dados necessários aos nossos programas. Isso significa que a alteração do estado anterior do histórico da conta deve ser verificada a cada tick. Se uma alteração for detectada, a lista do histórico de ordens e negócios deve ser recalculada. Mas ordenar o histórico inteiro a cada tick é muito custoso. Portanto, nós faremos apenas as adições à nossa lista de novos dados, enquanto os dados anteriores já estão armazenados na lista.
Vamos criar a nova classe CHistoryCollection na pasta Collections:
Clique com o botão direito do mouse na pasta Collections, selecione "Novo Arquivo", selecione "Nova Classe" na janela do Assistente MQL e clique em Avançar. Digite o nome da classe CHistoryCollection, deixe o campo da classe base em branco e clique em Concluir.
O novo arquivo HistoryCollection é gerado na pasta Collections:
//+------------------------------------------------------------------+ //| HistoryCollection.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CHistoryCollection { private: public: CHistoryCollection(); ~CHistoryCollection(); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::CHistoryCollection() { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::~CHistoryCollection() { } //+------------------------------------------------------------------+
Vamos preenchê-lo.
Nós vamos usar a lista dinâmica de ponteiros para instanciar objetos da biblioteca padrão CArrayObj para a lista. Inclua-o no arquivo e defina-o imediatamente (você pode usar o menu de contexto do botão direito para fazer isso):
Inclua a CArrayObj e defina a lista do histórico de ordens e negócios na seção private da classe:
//+------------------------------------------------------------------+ //| HistoryCollection.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include <Arrays\ArrayObj.mqh> //+------------------------------------------------------------------+ //| Coleção do histórico de ordens e negócios | //+------------------------------------------------------------------+ class CHistoryCollection { private: CArrayObj m_list_all_orders; // Lista do histórico de ordens e negócios public: CHistoryCollection(); ~CHistoryCollection(); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::CHistoryCollection() { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::~CHistoryCollection() { } //+------------------------------------------------------------------+
Nós precisamos salvar os índices das últimas ordens e negócios adicionados à coleção. Além disso, nós precisamos saber a diferença entre o número de ordens e negócios passados e atuais, portanto, nós vamos criar os membros da classe privada para armazená-los:
//+------------------------------------------------------------------+ //| HistoryCollection.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include <Arrays\ArrayObj.mqh> //+------------------------------------------------------------------+ //| Coleção do histórico de ordens e negócios | //+------------------------------------------------------------------+ class CHistoryCollection { private: CArrayObj m_list_all_orders; // Lista do histórico de ordens e negócios int m_index_order; // Índice da última ordem adicionada à coleção da lista do histórico do terminal (MQL4, MQL5) int m_index_deal; // Índice do último negócio adicionado à coleção da lista do histórico do terminal (MQL5) int m_delta_order; // Diferença no número de ordens em comparação com a verificação passada int m_delta_deal; // Diferença no número de negócios em comparação com a verificação passada public: CHistoryCollection(); ~CHistoryCollection(); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::CHistoryCollection() { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CHistoryCollection::~CHistoryCollection() { } //+------------------------------------------------------------------+
Durante a primeira execução, todos os membros da classe privada são redefinidos e o histórico é recalculado novamente. Para fazer isso, simplesmente adicione a lista de inicialização dos membros da classe no construtor da classe e defina o critério padrão para o qual a lista da coleção deve ser ordenada.
Atualmente, nós temos o construtor padrão. Antes de escrever sua implementação, nós devemos criar uma enumeração contendo todos os critérios possíveis para classificar as ordens e negócios na lista de coleção.
Mas primeiro, vamos organizar as propriedades do tipo inteiro, real e string da ordem para a sua exibição de forma mais lógica no diário. Abra o arquivo Define.mqh da pasta raiz da biblioteca e coloque os membros da enumeração na ordem necessária:
//+------------------------------------------------------------------+ //| Proprieades do tipo inteiro de ordem, negócio, posição | //+------------------------------------------------------------------+ enum ENUM_ORDER_PROP_INTEGER { ORDER_PROP_TICKET = 0, // Ticket da ordem ORDER_PROP_MAGIC, // Magic number da ordem ORDER_PROP_TIME_OPEN, // Horário de abertura (horário do negócio em MQL5) ORDER_PROP_TIME_CLOSE, // Horário de fechamento (horário de execução ou remoção em MQL5 - ORDER_TIME_DONE) ORDER_PROP_TIME_OPEN_MSC, // Horário de abertura em milissegundos (horário do negócio MQL5 em ms) ORDER_PROP_TIME_CLOSE_MSC, // Horário de abertura em milissegundos (horário de execução ou remoção em MQL5 - ORDER_TIME_DONE_MSC) ORDER_PROP_TIME_EXP, // Data de expiração da ordem (para ordens pendentes) ORDER_PROP_STATUS, // Estado da ordem (da enumeração ENUM_ORDER_STATUS) ORDER_PROP_TYPE, // Tipo da ordem (tipo da ordem em MQL5 deal type) ORDER_PROP_DIRECTION, // Direção (Buy, Sell) ORDER_PROP_REASON, // origem ou razão do negócio/ordem/posição ORDER_PROP_POSITION_ID, // ID da posição ORDER_PROP_POSITION_BY_ID, // ID da posição oposta ORDER_PROP_DEAL_ORDER, // Ordem, baseada no negócio executado ORDER_PROP_DEAL_ENTRY, // Direção do negócio – IN, OUT ou IN/OUT ORDER_PROP_TIME_UPDATE, // Horário da alteração da posição em segundos ORDER_PROP_TIME_UPDATE_MSC, // Horário da alteração da posição em milissegundos ORDER_PROP_TICKET_FROM, // ticket da ordem pai ORDER_PROP_TICKET_TO, // ticket da ordem derivada ORDER_PROP_PROFIT_PT, // Lucro em pontos ORDER_PROP_CLOSE_BY_SL, // Tipo do fechamento por StopLoss ORDER_PROP_CLOSE_BY_TP, // Tipo do fechamento por TakeProfit }; #define ORDER_PROP_INTEGER_TOTAL (22) // Número total de propriedades do tipo inteiro //+------------------------------------------------------------------+ //| Propriedades do tipo real de ordem, negócio, posição | //+------------------------------------------------------------------+ enum ENUM_ORDER_PROP_DOUBLE { ORDER_PROP_PRICE_OPEN = ORDER_PROP_INTEGER_TOTAL, // Preço de abertura (preço do negócio MQL5) ORDER_PROP_PRICE_CLOSE, // Preço de fechamento ORDER_PROP_SL, // Preço do StopLoss ORDER_PROP_TP, // Preço do TakeProfit ORDER_PROP_PROFIT, // Lucro ORDER_PROP_COMMISSION, // Comissão ORDER_PROP_SWAP, // Swap ORDER_PROP_VOLUME, // Volume ORDER_PROP_VOLUME_CURRENT, // Volume não executado ORDER_PROP_PROFIT_FULL, // Lucro+comissão+swap ORDER_PROP_PRICE_STOP_LIMIT, // Preço da ordem limitada quando a ordem StopLimit é ativada }; #define ORDER_PROP_DOUBLE_TOTAL (11) // Número total de propriedades do tipo real //+------------------------------------------------------------------+ //| Propriedades do tipo string de ordem, negócio, posição | //+------------------------------------------------------------------+ enum ENUM_ORDER_PROP_STRING { ORDER_PROP_SYMBOL = (ORDER_PROP_INTEGER_TOTAL+ORDER_PROP_DOUBLE_TOTAL), // Símbolo da ordem ORDER_PROP_COMMENT, // Comentário da ordem ORDER_PROP_EXT_ID // ID da ordem em um sistema de negociação externo }; #define ORDER_PROP_STRING_TOTAL (3) // Número total de propriedades do tipo string //+------------------------------------------------------------------+
Agora vamos adicionar a enumeração com todos os tipos possíveis de classificação de ordem e negócio para o mesmo arquivo:
//+------------------------------------------------------------------+ //| Possíveis critérios de classificação de ordens e negócios | //+------------------------------------------------------------------+ enum ENUM_SORT_ORDERS_MODE { //--- Classifica por propriedades do tipo inteiro SORT_BY_ORDER_TICKET = 0, // Classifica pelo ticket da ordem SORT_BY_ORDER_MAGIC = 1, // Classifia pelo número mágico da ordem SORT_BY_ORDER_TIME_OPEN = 2, // Classifica pelo horário de abertura da ordem SORT_BY_ORDER_TIME_CLOSE = 3, // Classifica pelo horário de fechamento da ordem SORT_BY_ORDER_TIME_OPEN_MSC = 4, // Classifica pelo horário de abertura da ordem em milissegundos SORT_BY_ORDER_TIME_CLOSE_MSC = 5, // Classifica pelo horário de fechamento da ordem em milissegundos SORT_BY_ORDER_TIME_EXP = 6, // Classifica pela data de expiração da ordem SORT_BY_ORDER_STATUS = 7, // Classifica pelo estado da ordem (ordem à mercado/ordem pendente/negócio) SORT_BY_ORDER_TYPE = 8, // Classifica pelo tipo da ordem SORT_BY_ORDER_REASON = 10, // Classifica pelo negócio/ordem/posição/razão/origem SORT_BY_ORDER_POSITION_ID = 11, // Classifica pelo ID da posição SORT_BY_ORDER_POSITION_BY_ID = 12, // Classifica pelo ID da posição oposta SORT_BY_ORDER_DEAL_ORDER = 13, // Classifica pela ordem que o negócio se baseou SORT_BY_ORDER_DEAL_ENTRY = 14, // Classifica pela direção do negócio – IN, OUT ou IN/OUT SORT_BY_ORDER_TIME_UPDATE = 15, // Classifica pelo horário de alteração da posição em segundos SORT_BY_ORDER_TIME_UPDATE_MSC = 16, // Classifica pelo horário de alteração da posição em milissegundos SORT_BY_ORDER_TICKET_FROM = 17, // Classifica pelo ticket da ordem pai SORT_BY_ORDER_TICKET_TO = 18, // Classifica pelo ticket da ordem derivada SORT_BY_ORDER_PROFIT_PT = 19, // Classifica pelo lucro da ordem em pontos SORT_BY_ORDER_CLOSE_BY_SL = 20, // Classifica pelo fechamento da ordem pela flag StopLoss SORT_BY_ORDER_CLOSE_BY_TP = 21, // Classifica pelo fechamento da ordem pela flag TakeProfit //--- Classifica por propriedades do tipo real SORT_BY_ORDER_PRICE_OPEN = ORDER_PROP_INTEGER_TOTAL,// Classifica pelo preço de abertura SORT_BY_ORDER_PRICE_CLOSE = 23, // Classifica pelo preço do fechamento SORT_BY_ORDER_SL = 24, // Classifica pelo preço de StopLoss SORT_BY_ORDER_TP = 25, // Classifica pelo preço de TakeProfit SORT_BY_ORDER_PROFIT = 26, // Classifica pelo lucro SORT_BY_ORDER_COMMISSION = 27, // Classifica pela comissão SORT_BY_ORDER_SWAP = 28, // Classifica pelo swap SORT_BY_ORDER_VOLUME = 29, // Classifica pelo volume SORT_BY_ORDER_VOLUME_CURRENT = 30, // Classifica pelo volume não executado SORT_BY_ORDER_PROFIT_FULL = 31, // Classifica pelo critério de lucro+comissão+swap SORT_BY_ORDER_PRICE_STOP_LIMIT= 32, // Classifica pela ordem limitada quando a ordem StopLimit é ativada //--- Classifica pelas propriedades do tipo string SORT_BY_ORDER_SYMBOL = ORDER_PROP_INTEGER_TOTAL+ORDER_PROP_DOUBLE_TOTAL,// Classifica pelo símbolo SORT_BY_ORDER_COMMENT = 34, // Classifica pelo comentário SORT_BY_ORDER_EXT_ID = 35 // Classifica pelo ID da ordem em um sistema de negociação externo }; //+------------------------------------------------------------------+
Nota: Os índices dos membros da enumeração ordenados devem coincidir com um dos membros da enumeração de propriedades, uma vez que a lista deve ser classificada pelo mesmo valor que é usado para a busca nessa lista.
Como nós podemos ver, a propriedade de classificação ORDER_PROP_DIRECTION foi ignorada nessa lista, já que essa é uma propriedade de serviço usada para as necessidades da biblioteca, assim como outras propriedades personalizadas que nós adicionamos anteriormente. No entanto, eles podem precisar de ordenação. É por isso que eles foram deixados.
Agora nós podemos implementar o construtor da classe CHistoryCollection:
//+------------------------------------------------------------------+ //| HistoryCollection.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Arquivos de inclusão | //+------------------------------------------------------------------+ #include <Arrays\ArrayObj.mqh> #include "..\DELib.mqh" //+------------------------------------------------------------------+ //| Coleção do histórico de ordens e negócios | //+------------------------------------------------------------------+ class CHistoryCollection { private: CArrayObj m_list_all_orders; // Lista do histórico de ordens e negócios int m_index_order; // Índice da última ordem adicionada à coleção da lista do histórico do terminal (MQL4, MQL5) int m_index_deal; // Índice do último negócio adicionado à coleção da lista do histórico do terminal (MQL5) int m_delta_order; // Diferença no número de ordens em comparação com a verificação passada int m_delta_deal; // Diferença no número de negócios em comparação com a verificação passada public: CHistoryCollection(); ~CHistoryCollection(); }; //+------------------------------------------------------------------+ //| Construtor | //+------------------------------------------------------------------+ CHistoryCollection::CHistoryCollection(void) : m_index_deal(0), m_delta_deal(0), m_index_order(0), m_delta_order(0) { m_list_all_orders.Sort(SORT_BY_ORDER_TIME_CLOSE); } //+------------------------------------------------------------------+
Vamos analisar o código.
Como o construtor da classe usa apenas o valor de uma enumeração recém-adicionada, nós devemos incluir o arquivo Defines.mqh no arquivo da classe.
Ao preparar a classe base e abstrata COrder no primeiro artigo, nós desenvolvemos a biblioteca de funções de serviço DELib.mqh e incluiu o arquivo Defines.mqh com todas as enumerações necessárias e substituições de macro para ele. Assim sendo, nós vamos incluir a biblioteca de funções de serviço.
Na lista de inicialização do construtor, todos os índices e valores das diferenças entre os números atuais e anteriores são redefinidos, e a classificação padrão por hora de fechamento é especificada no corpo do construtor.
Agora é hora de começar a coletar as informações da conta e salvá-las na lista de coleção. Para fazer isso, percorra o histórico da conta em loops e especifique cada ordem na lista. Se o número de ordens ou negócios se alterar em comparação com a verificação anterior, defina a flag do evento de negociação ocorrido. É necessário enviar mensagens sobre o novo evento ocorrido no histórico da conta para um programa externo.
Declare a flag de evento de negociação na seção da classe privada e o método Refresh() para atualizar a coleção do histórico na seção pública:
//+------------------------------------------------------------------+ //| Coleção do histórico de ordens e negócios | //+------------------------------------------------------------------+ class CHistoryCollection { private: CArrayObj m_list_all_orders; // Lista de todo o histórico de ordens e negócios bool m_is_trade_event; // Flag do evento de negociação int m_index_order; // Índice da última ordem adicionada à coleção da lista do histórico do terminal (MQL4, MQL5) int m_index_deal; // Índice do último negócio adicionado à coleção da lista do histórico do terminal (MQL5) int m_delta_order; // Diferença no número de ordens em comparação com a verificação passada int m_delta_deal; // Diferença no número de negócios em comparação com a verificação passada public: CHistoryCollection(); //--- Atualiza a lista de ordens, preenche os dados sobre o número de novas ordens e define a flag do evento de negociação void Refresh(void); }; //+------------------------------------------------------------------+
Para implementar a atualização da lista de ordens da coleção, nós precisamos de mais uma substituição de macro para solicitar os dados completos do histórico. A função HistorySelect() é usada para isso. As datas do início e fim dos dados requeridos são passadas em seus parâmetros. Para obter a lista completa do histórico da conta, a data inicial deve ser passada como 0, enquanto a final deve ser passada como TimeCurrent(). No entanto, nesse caso, os dados do histórico retornado podem, às vezes, estar incompletos. Para evitar isso, insira uma data excedendo a hora atual do servidor em vez de TimeCurrent(). Eu vou inserir a data máxima possível: 31.12.3000 23:59:59. Outra vantagem aqui é que os símbolos personalizados podem conter essa data e a obtenção do histórico ainda funcionará.
Vamos inserir uma nova substituição de macros para o arquivo Defines.mqh:
//+------------------------------------------------------------------+ //| Defines.mqh | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" //+------------------------------------------------------------------+ //| Substituições de macro | //+------------------------------------------------------------------+ #define COUNTRY_LANG ("Russian") // Idioma do país #define DFUN (__FUNCTION__+": ") // "Descrição da função" #define END_TIME (D'31.12.3000 23:59:59') // Hora de término para solicitar os dados do histórico da conta //+------------------------------------------------------------------+
Agora, em vez de entrar com TimeCurrent() como a hora final, nós vamos inserir a macro END_TIME.
Implementando a atualização da lista order da coleção:
//+------------------------------------------------------------------+ //| Atualiza a lista order | //+------------------------------------------------------------------+ void CHistoryCollection::Refresh(void) { #ifdef __MQL4__ int total=::OrdersHistoryTotal(),i=m_index_order; for(; i<total; i++) { if(!::OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)) continue; ENUM_ORDER_TYPE order_type=(ENUM_ORDER_TYPE)::OrderType(); //--- Posições fechadas e operações de saldo/crédito if(order_type<ORDER_TYPE_BUY_LIMIT || order_type>ORDER_TYPE_SELL_STOP) { CHistoryOrder *order=new CHistoryOrder(::OrderTicket()); if(order==NULL) continue; m_list_all_orders.InsertSort(order); } else { //--- Ordens pendentes removidas CHistoryPending *order=new CHistoryPending(::OrderTicket()); if(order==NULL) continue; m_list_all_orders.InsertSort(order); } } //--- int delta_order=i-m_index_order; this.m_index_order=i; this.m_delta_order=delta_order; this.m_is_trade_event=(this.m_delta_order!=0 ? true : false); //--- __MQL5__ #else if(!::HistorySelect(0,END_TIME)) return; //--- Ордера int total_orders=::HistoryOrdersTotal(),i=m_index_order; for(; i<total_orders; i++) { ulong order_ticket=::HistoryOrderGetTicket(i); if(order_ticket==0) continue; ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)::HistoryOrderGetInteger(order_ticket,ORDER_TYPE); if(type==ORDER_TYPE_BUY || type==ORDER_TYPE_SELL) { CHistoryOrder *order=new CHistoryOrder(order_ticket); if(order==NULL) continue; m_list_all_orders.InsertSort(order); } else { CHistoryPending *order=new CHistoryPending(order_ticket); if(order==NULL) continue; m_list_all_orders.InsertSort(order); } } //--- salva o índice da última ordem adicionada e a diferença em comparação com a verificação anterior int delta_order=i-this.m_index_order; this.m_index_order=i; this.m_delta_order=delta_order; //--- Negócios int total_deals=::HistoryDealsTotal(),j=m_index_deal; for(; j<total_deals; j++) { ulong deal_ticket=::HistoryDealGetTicket(j); if(deal_ticket==0) continue; CHistoryDeal *deal=new CHistoryDeal(deal_ticket); if(deal==NULL) continue; m_list_all_orders.InsertSort(deal); } //--- salve o índice do último negócio adicionado e a diferença em comparação com a verificação anterior int delta_deal=j-this.m_index_deal; this.m_index_deal=j; this.m_delta_deal=delta_deal; //--- Define a nova flag de evento no histórico this.m_is_trade_event=(this.m_delta_order+this.m_delta_deal); #endif } //+------------------------------------------------------------------+
Verifica a afiliação com a MQL4 ou MQL5. Vamos analisar o código usando a MQL5 como exemplo, já que ela é um pouco mais complicada.
Primeiro, solicite o histórico completo da conta. Se falhar, saia até o próximo tick. Após a solicitação do histórico bem-sucedida, duas listas são criadas — lista de ordens e negócios.
Primeiro, percorra ao longo da lista de todas as ordens em um loop. O índice inicial do loop é um resultado da operação do loop anterior (no começo start = 0). Isso nos permite percorrer apenas através de novas ordens que apareceram no histórico desde a última verificação, em vez de percorrer um loop custoso ao longo de todo o histórico.
Em seguida, obtenha o ticket da ordem e o seu tipo. Crie um novo objeto de acordo com o resultado da verificação do tipo da ordem (um histórico de ordem à mercado ou de ordem pendente removida) e coloque-o na lista da coleção ordenada de forma imediata (já definimos a classificação por horário de fechamento antes).
Após a conclusão da operação de loop, salve o índice da nova ordem de modo que um novo loop comece a partir dele. A diferença entre os resultados da operação de loops anteriores e atuais é o número de ordens recém-adicionadas.
O loop para trabalhar com os negócios é o mesmo, exceto que não há necessidade de dividir os negócios por tipos. Em vez disso, você pode adicionar um objeto deal à lista da coleção imediatamente.
O loop no código em MQL4 é quase o mesmo, exceto que o loop é obtido de todo o histórico possível da conta. O comprimento do histórico é especificado por um usuário na guia Histórico do terminal, o que significa que cabe aos usuários garantir que todo o histórico esteja disponível, se o programa exigir. Outra opção é usar a WinAPI para obter o histórico inteiro, o que está além do escopo dos artigos.
Após a conclusão dos loops, o número de novas ordens e negócios é verificada. Se o número for maior que zero, a flag do evento de negociação ocorrido é definido.
Nós implementamos a obtenção dos dados na classe da coleção de histórico semelhante à implementada no teste do EA na primeira parte, exceto que no caso atual, diferentes objetos do histórico de ordens são criados separados pelo seu estado. A fim de verificar como tudo isso funciona, nós precisamos obter a lista da coleção criada do histórico de ordens do lado de fora (do programa que usa esta biblioteca; no nosso caso, este é um EA de teste).
Para fazer isso, adicione o método GetList() sem parâmetros para a seção public da classe CHistoryCollection (no próximo artigo, eu adicionarei os métodos para receber a lista com parâmetros)://+------------------------------------------------------------------+ //| Coleção do histórico de ordens e negócios | //+------------------------------------------------------------------+ class CHistoryCollection { private: CArrayObj m_list_all_orders; // Lista de todo o histórico de ordens e negócios bool m_is_trade_event; // Flag do evento de negociação int m_index_order; // Índice da última ordem adicionada à coleção da lista do histórico do terminal (MQL4, MQL5) int m_index_deal; // Índice do último negócio adicionado à coleção da lista do histórico do terminal (MQL5) int m_delta_order; // Diferença no número de ordens em comparação com a verificação passada int m_delta_deal; // Diferença no número de negócios em comparação com a verificação passada public: //--- Retorna a lista completa da coleção 'como está' CArrayObj* GetList(void) { return &m_list_all_orders; } //--- Construtor CHistoryCollection(); //--- Atualiza a lista de ordens, preenche os dados sobre o número de novas ordens e configura o evento de negociação void Refresh(void); }; //+------------------------------------------------------------------+
Como pode ser visto na listagem, o ponteiro para a lista (não o objeto em si) é retornado. Isso é suficiente para usar a lista nos programas. No entanto, isso é insuficiente para o uso rápido e fácil da biblioteca. No próximo artigo dedicado à biblioteca, eu implementarei um acesso fácil aos dados necessários mediante solicitação. Nos próximos artigos, eu vou simplificar ainda mais o acesso, criando funções especiais para trabalhar com a biblioteca em programas personalizados.
Vamos ver como a lista está preenchida. Para fazer isso, crie um pequeno EA. Na pasta TestDoEasy (que nós já criamos na primeira parte), gere a subpasta Part02. Ele conterá o arquivo do segundo EA de teste chamado TestDoEasyPart02 e conecte a coleção criada a ela:
//+------------------------------------------------------------------+ //| TestDoEasyPart02.mq5 | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //--- includes #include <DoEasy\Collections\HistoryCollection.mqh> //+------------------------------------------------------------------+ //| Função de inicialização do Expert | //+------------------------------------------------------------------+ int OnInit() { //--- //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Função de desinicialização do Expert | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Função Tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- } //+------------------------------------------------------------------+
Como a lista agora armazena os objetos de vários tipos herdados do único pai COrder, vamos implementar a exibição das descrições dos objetos selecionados no diário. Para fazer isso, crie a enumeração com a seleção dos tipos de ordens exibidos nas entradas, bem como o objeto da coleção para ler os dados da conta:
//+------------------------------------------------------------------+ //| TestDoEasyPart02.mq5 | //| Copyright 2018, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2018, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //--- includes #include <DoEasy\Collections\HistoryCollection.mqh> //--- enums enum ENUM_TYPE_ORDERS { TYPE_ORDER_MARKET, // Ordens à mercado TYPE_ORDER_PENDING, // Ordens pendentes TYPE_ORDER_DEAL // Negócios }; //--- parâmetros de entrada input ENUM_TYPE_ORDERS InpOrderType = TYPE_ORDER_DEAL; // Tipo da exibição: //--- variáveis globais CHistoryCollection history; //+------------------------------------------------------------------+ //| Função de inicialização do Expert | //+------------------------------------------------------------------+
Como no teste anterior do EA da primeira parte da descrição da biblioteca, leia o histórico da conta no manipulador OnInit() e exiba as informações sobre as ordens para o diário em um loop:
//+------------------------------------------------------------------+ //| Função de inicialização do Expert | //+------------------------------------------------------------------+ int OnInit() { //--- atualiza o histórico history.Refresh(); //--- obtém o ponteiro para a lista completa da coleção CArrayObj* list=history.GetList(); if(list==NULL) { Print("Could not get collection list"); return INIT_FAILED; } int total=list.Total(); for(int i=0;i<total;i++) { //--- obtém a ordem da lista COrder* order=list.At(i); if(order==NULL) continue; //--- se isso é um negócio if(order.Status()==ORDER_STATUS_DEAL && InpOrderType==TYPE_ORDER_DEAL) order.Print(); //--- se esta for o histórico da ordem à mercado if(order.Status()==ORDER_STATUS_HISTORY_ORDER && InpOrderType==TYPE_ORDER_MARKET) order.Print(); //--- se esta for uma ordem pendente removida if(order.Status()==ORDER_STATUS_HISTORY_PENDING && InpOrderType==TYPE_ORDER_PENDING) order.Print(); } //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Aqui, crie um ponteiro para a lista da coleção e receba-o de CHistoryCollection usando o método GetList(), que foi criado lá.
Em seguida, em um loop, obtenha o objeto order da lista, verifique seu estado e permissão para exibir os dados no diário nas configurações do EA.
Dependendo dos resultados, exiba os dados no diário ou não.
No entanto, nós obtemos o objeto base COrder da lista, apenas os dados inerentes aos descendentes da ordem base são exibidos no diário — ordens à mercado, ordens pendentes e negócios com métodos virtuais redefinidos que retornam a flag, indicando que a ordem suporta apenas suas propriedades inerentes.
Compile e execute o EA. O jornal exibe os dados sobre os tipos de ordens e negócios selecionados:
Se você olhar de perto os tipos de propriedades exibidas, nós veremos as propriedades que não são típicas das ordens em MQL5: lucro, swap, comissão e lucro em pontos.
Vamos fazer algumas melhorias e adições nos objetos já criados.
Adicione a propriedade não suportada Lucro em MQL5 em pontos para o método SupportProperty(ENUM_ORDER_PROP_INTEGER property) da classe CHistoryOrder:
//+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryOrder::SupportProperty(ENUM_ORDER_PROP_INTEGER property) { if(property==ORDER_PROP_TIME_EXP || property==ORDER_PROP_DEAL_ENTRY || property==ORDER_PROP_TIME_UPDATE || property==ORDER_PROP_TIME_UPDATE_MSC #ifdef __MQL5__ || property==ORDER_PROP_PROFIT_PT #endif ) return false; return true; } //+------------------------------------------------------------------+
e ainda adiciona outro método virtual retornando o suporte de propriedades do tipo real pelas ordens:
//+------------------------------------------------------------------+ //| Histórico da ordem à mercado | //+------------------------------------------------------------------+ class CHistoryOrder : public COrder { public: //--- Construtor CHistoryOrder(const ulong ticket) : COrder(ORDER_STATUS_HISTORY_ORDER,ticket) {} //--- Propriedades do tipo inteiro suportadas de uma ordem virtual bool SupportProperty(ENUM_ORDER_PROP_INTEGER property); //--- Propriedades do tipo real suportadas de uma ordem virtual bool SupportProperty(ENUM_ORDER_PROP_DOUBLE property); }; //+------------------------------------------------------------------+
bem como a sua implementação:
//+------------------------------------------------------------------+ //| Retorna 'true' se a ordem suportar a propriedade passada, | //| caso contrário, retorna 'false' | //+------------------------------------------------------------------+ bool CHistoryOrder::SupportProperty(ENUM_ORDER_PROP_DOUBLE property) { #ifdef __MQL5__ if(property==ORDER_PROP_PROFIT || property==ORDER_PROP_PROFIT_FULL || property==ORDER_PROP_SWAP || property==ORDER_PROP_COMMISSION || property==ORDER_PROP_PRICE_STOP_LIMIT ) return false; #endif return true; } //+------------------------------------------------------------------+
Se for em MQL5, o lucro, swap, comissão, lucro total e preço da ordem StopLimit não são suportados. Para MQL4 e outras propriedades de ordem do tipo real em MQL5, retorna a flag do suporte da ordem para as propriedades do tipo real.
As ordens em MQL5 também possuem a propriedade ORDER_STATE. Esta é o estado da ordem definido na enumeração ENUM_ORDER_STATE.
Adicione-o à lista de propriedades da ordem inteira (a enumeração ENUM_ORDER_PROP_INTEGER nos arquivos Defines.mqh):
//+------------------------------------------------------------------+ //| Proprieades do tipo inteiro de ordem, negócio, posição | //+------------------------------------------------------------------+ enum ENUM_ORDER_PROP_INTEGER { ORDER_PROP_TICKET = 0, // Ticket da ordem ORDER_PROP_MAGIC, // Magic number da ordem ORDER_PROP_TIME_OPEN, // Horário de abertura (horário do negócio em MQL5) ORDER_PROP_TIME_CLOSE, // Horário de fechamento (horário de execução ou remoção em MQL5 - ORDER_TIME_DONE) ORDER_PROP_TIME_OPEN_MSC, // Horário de abertura em milissegundos (horário do negócio MQL5 em ms) ORDER_PROP_TIME_CLOSE_MSC, // Horário de abertura em milissegundos (horário de execução ou remoção em MQL5 - ORDER_TIME_DONE_MSC) ORDER_PROP_TIME_EXP, // Data de expiração da ordem (para ordens pendentes) ORDER_PROP_STATUS, // Estado da ordem (da enumeração ENUM_ORDER_STATUS) ORDER_PROP_TYPE, // Tipo da ordem (tipo da ordem em MQL5 deal type) ORDER_PROP_DIRECTION, // Direção (Buy, Sell) ORDER_PROP_REASON, // origem ou razão do negócio/ordem/posição ORDER_PROP_STATE, // Estado da ordem (da enumeração ENUM_ORDER_STATE) ORDER_PROP_POSITION_ID, // ID da posição ORDER_PROP_POSITION_BY_ID, // ID da posição oposta ORDER_PROP_DEAL_ORDER, // Ordem, baseada no negócio executado ORDER_PROP_DEAL_ENTRY, // Direção do negócio – IN, OUT ou IN/OUT ORDER_PROP_TIME_UPDATE, // Horário da alteração da posição em segundos ORDER_PROP_TIME_UPDATE_MSC, // Horário da alteração da posição em milissegundos ORDER_PROP_TICKET_FROM, // ticket da ordem pai ORDER_PROP_TICKET_TO, // ticket da ordem derivada ORDER_PROP_PROFIT_PT, // Lucro em pontos ORDER_PROP_CLOSE_BY_SL, // Tipo do fechamento por StopLoss ORDER_PROP_CLOSE_BY_TP, // Tipo do fechamento por TakeProfit }; #define ORDER_PROP_INTEGER_TOTAL (23) // Número total de propriedades do tipo inteiro //+------------------------------------------------------------------+
e certifique-se de alterar o número de propriedades do tipo inteiro da ordem de 22 para 23 na substituição de macro ORDER_PROP_INTEGER_TOTAL indicando o número de propriedades do tipo inteiro da ordem e usado para calcular o "endereço" exato da propriedade da ordem necessária.
No mesmo arquivo, adicione a nova propriedade aos possíveis critérios de classificação de ordem, para que possamos classificar as ordens por essa nova propriedade e implementar o cálculo mais conveniente de índices no caso de uma mudança subsequente das enumerações:
//+------------------------------------------------------------------+ //| Possíveis critérios de classificação de ordens e negócios | //+------------------------------------------------------------------+ #define FIRST_DBL_PROP (ORDER_PROP_INTEGER_TOTAL) #define FIRST_STR_PROP (ORDER_PROP_INTEGER_TOTAL+ORDER_PROP_DOUBLE_TOTAL) enum ENUM_SORT_ORDERS_MODE { //--- Classifica por propriedades do tipo inteiro SORT_BY_ORDER_TICKET = 0, // Classifica pelo ticket da ordem SORT_BY_ORDER_MAGIC = 1, // Classifia pelo número mágico da ordem SORT_BY_ORDER_TIME_OPEN = 2, // Classifica pelo horário de abertura da ordem SORT_BY_ORDER_TIME_CLOSE = 3, // Classifica pelo horário de fechamento da ordem SORT_BY_ORDER_TIME_OPEN_MSC = 4, // Classifica pelo horário de abertura da ordem em milissegundos SORT_BY_ORDER_TIME_CLOSE_MSC = 5, // Classifica pelo horário de fechamento da ordem em milissegundos SORT_BY_ORDER_TIME_EXP = 6, // Classifica pela data de expiração da ordem SORT_BY_ORDER_STATUS = 7, // Classifica pelo estado da ordem (ordem à mercado/ordem pendente/negócio) SORT_BY_ORDER_TYPE = 8, // Classifica pelo tipo da ordem SORT_BY_ORDER_REASON = 10, // Classifica pelo negócio/ordem/posição/razão/origem SORT_BY_ORDER_STATE = 11, // Classifica pelo estado da ordem SORT_BY_ORDER_POSITION_ID = 12, // Classifica pelo ID da posição SORT_BY_ORDER_POSITION_BY_ID = 13, // Classifica pelo ID da posição oposta SORT_BY_ORDER_DEAL_ORDER = 14, // Classifica pela ordem que o negócio se baseou SORT_BY_ORDER_DEAL_ENTRY = 15, // Classifica pela direção do negócio – IN, OUT ou IN/OUT SORT_BY_ORDER_TIME_UPDATE = 16, // Classifica pelo horário de alteração da posição em segundos SORT_BY_ORDER_TIME_UPDATE_MSC = 17, // Classifica pelo horário de alteração da posição em milissegundos SORT_BY_ORDER_TICKET_FROM = 18, // Classifica pelo ticket da ordem pai SORT_BY_ORDER_TICKET_TO = 19, // Classifica pelo ticket da ordem derivada SORT_BY_ORDER_PROFIT_PT = 20, // Classifica pelo lucro da ordem em pontos SORT_BY_ORDER_CLOSE_BY_SL = 21, // Classifica pelo fechamento da ordem pela flag StopLoss SORT_BY_ORDER_CLOSE_BY_TP = 22, // Classifica pelo fechamento da ordem pela flag TakeProfit //--- Classifica por propriedades do tipo real SORT_BY_ORDER_PRICE_OPEN = FIRST_DBL_PROP, // Classifica pelo preço de abertura SORT_BY_ORDER_PRICE_CLOSE = FIRST_DBL_PROP+1, // Classifica pelo preço do fechamento SORT_BY_ORDER_SL = FIRST_DBL_PROP+2, // Classifica pelo preço de StopLoss SORT_BY_ORDER_TP = FIRST_DBL_PROP+3, // Classifica pelo preço de TakeProfit SORT_BY_ORDER_PROFIT = FIRST_DBL_PROP+4, // Classifica pelo lucro SORT_BY_ORDER_COMMISSION = FIRST_DBL_PROP+5, // Classifica pela comissão SORT_BY_ORDER_SWAP = FIRST_DBL_PROP+6, // Classifica pelo swap SORT_BY_ORDER_VOLUME = FIRST_DBL_PROP+7, // Classifica pelo volume SORT_BY_ORDER_VOLUME_CURRENT = FIRST_DBL_PROP+8, // Classifica pelo volume não executado SORT_BY_ORDER_PROFIT_FULL = FIRST_DBL_PROP+9, // Classifica pelo critério de lucro+comissão+swap SORT_BY_ORDER_PRICE_STOP_LIMIT= FIRST_DBL_PROP+10, // Classifica pela ordem limitada quando a ordem StopLimit é ativada //--- Classifica pelas propriedades do tipo string SORT_BY_ORDER_SYMBOL = FIRST_STR_PROP, // Classifica pelo símbolo SORT_BY_ORDER_COMMENT = FIRST_STR_PROP+1, // Classifica pelo comentário SORT_BY_ORDER_EXT_ID = FIRST_STR_PROP+2 // Classifica pelo ID da ordem em um sistema de negociação externo }; //+------------------------------------------------------------------+
Na seção protected da classe abstrata COrder do arquivo Order.mqh, declare o método OrderState() escrevendo seu estado a partir da enumeração ENUM_ORDER_STATE para as propriedades da ordem:
protected: //--- Construtor paramétrico protegido COrder(ENUM_ORDER_STATUS order_status,const ulong ticket); //--- Obtém e retorna as propriedades do tipo inteiro de uma ordem selecionada de seus parâmetros long OrderMagicNumber(void) const; long OrderTicket(void) const; long OrderTicketFrom(void) const; long OrderTicketTo(void) const; long OrderPositionID(void) const; long OrderPositionByID(void) const; long OrderOpenTimeMSC(void) const; long OrderCloseTimeMSC(void) const; long OrderType(void) const; long OrderState(void) const; long OrderTypeByDirection(void) const; long OrderTypeFilling(void) const; long OrderTypeTime(void) const; long OrderReason(void) const; long DealOrder(void) const; long DealEntry(void) const; bool OrderCloseByStopLoss(void) const; bool OrderCloseByTakeProfit(void) const; datetime OrderOpenTime(void) const; datetime OrderCloseTime(void) const; datetime OrderExpiration(void) const; datetime PositionTimeUpdate(void) const; datetime PositionTimeUpdateMSC(void) const;
e adicione a sua implementação:
//+------------------------------------------------------------------+ //| Retorna o estado da ordem | //+------------------------------------------------------------------+ long COrder::OrderState(void) const { #ifdef __MQL4__ return ORDER_STATE_FILLED; #else long res=0; switch((ENUM_ORDER_STATUS)this.GetProperty(ORDER_PROP_STATUS)) { case ORDER_STATUS_HISTORY_PENDING : case ORDER_STATUS_HISTORY_ORDER : res=::HistoryOrderGetInteger(m_ticket,ORDER_STATE); break; case ORDER_STATUS_MARKET_PENDING : res=::OrderGetInteger(ORDER_STATE); break; case ORDER_STATUS_MARKET_ACTIVE : case ORDER_STATUS_DEAL : default : res=0; break; } return res; #endif } //+------------------------------------------------------------------+
No caso da MQL4, vamos retornar a execução completa da ordem por agora. No caso da MQL5, ou return 0 (se for um negócio ou uma posição) ou o estado da ordem (se for uma ordem à mercado ou pendente) dependendo do estado da ordem.
Na seção public da classe COrder, declare o método retornando a descrição do estado da ordem:
//+------------------------------------------------------------------+ //| Descrições de propriedades de objetos da ordem | //+------------------------------------------------------------------+ //--- Obtém a descrição da propriedade do tipo (1) inteiro, (2) real e (3) string string GetPropertyDescription(ENUM_ORDER_PROP_INTEGER property); string GetPropertyDescription(ENUM_ORDER_PROP_DOUBLE property); string GetPropertyDescription(ENUM_ORDER_PROP_STRING property); //--- Retorna o nome do estado da ordem string StatusDescription(void) const; //--- Retorna a ordem ou o nome da posição string TypeDescription(void) const; //--- Retorna a descrição do estado da ordem string StateDescription(void) const; //--- Retorna o nome da direção do negócio string DealEntryDescription(void) const; //--- Retorna o tipo da direção da ordem/posição string DirectionDescription(void) const; //--- Envia a descrição das propriedades da ordem para o diário (full_prop=true - todas as propriedades, false - apenas as suportadas) void Print(const bool full_prop=false);
bem como a sua implementação:
//+------------------------------------------------------------------+ //| Retorna a descrição do estado da ordem | //+------------------------------------------------------------------+ string COrder::StateDescription(void) const { if(this.Status()==ORDER_STATUS_DEAL || this.Status()==ORDER_STATUS_MARKET_ACTIVE) return ""; else switch(this.StateOrder()) { case ORDER_STATE_STARTED : return TextByLanguage("Ордер проверен на корректность, но еще не принят брокером","Order checked for correctness, but not yet accepted by broker"); case ORDER_STATE_PLACED : return TextByLanguage("Ордер принят","Order accepted"); case ORDER_STATE_CANCELED : return TextByLanguage("Ордер снят клиентом","Order withdrawn by client"); case ORDER_STATE_PARTIAL : return TextByLanguage("Ордер выполнен частично","Order filled partially"); case ORDER_STATE_FILLED : return TextByLanguage("Ордер выполнен полностью","Order filled"); case ORDER_STATE_REJECTED : return TextByLanguage("Ордер отклонен","Order rejected"); case ORDER_STATE_EXPIRED : return TextByLanguage("Ордер снят по истечении срока его действия","Order withdrawn upon expiration"); case ORDER_STATE_REQUEST_ADD : return TextByLanguage("Ордер в состоянии регистрации (выставление в торговую систему)","Order in state of registration (placing in trading system)"); case ORDER_STATE_REQUEST_MODIFY : return TextByLanguage("Ордер в состоянии модификации","Order in state of modification."); case ORDER_STATE_REQUEST_CANCEL : return TextByLanguage("Ордер в состоянии удаления","Order in deletion state"); default : return TextByLanguage("Неизвестное состояние","Unknown state"); } } //+------------------------------------------------------------------+
Se esta for um negócio ou uma posição, retorne uma string vazia, caso contrário, verifique o estado da ordem e retorna a sua descrição.
Adiciona o retorno da descrição do estado da ordem na implementação do método GetPropertyDescription(ENUM_ORDER_PROP_INTEGER):
//+------------------------------------------------------------------+ //| Retorna a descrição da propriedade do tipo inteiro de uma ordem | //+------------------------------------------------------------------+ string COrder::GetPropertyDescription(ENUM_ORDER_PROP_INTEGER property) { return ( //--- Propriedades gerais property==ORDER_PROP_MAGIC ? TextByLanguage("Магик","Magic number")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(string)this.GetProperty(property) ) : property==ORDER_PROP_TICKET ? TextByLanguage("Тикет","Ticket")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : " #"+(string)this.GetProperty(property) ) : property==ORDER_PROP_TICKET_FROM ? TextByLanguage("Тикет родительского ордера","Ticket of parent order")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : " #"+(string)this.GetProperty(property) ) : property==ORDER_PROP_TICKET_TO ? TextByLanguage("Тикет наследуемого ордера","Inherited order ticket")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : " #"+(string)this.GetProperty(property) ) : property==ORDER_PROP_TIME_OPEN ? TextByLanguage("Время открытия","Open time")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES|TIME_SECONDS) ) : property==ORDER_PROP_TIME_CLOSE ? TextByLanguage("Время закрытия","Close time")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES|TIME_SECONDS) ) : property==ORDER_PROP_TIME_EXP ? TextByLanguage("Дата экспирации","Expiration date")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : (this.GetProperty(property)==0 ? TextByLanguage(": Не задана",": Not set") : ": "+::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES|TIME_SECONDS)) ) : property==ORDER_PROP_TYPE ? TextByLanguage("Тип","Type")+": "+this.TypeDescription() : property==ORDER_PROP_DIRECTION ? TextByLanguage("Тип по направлению","Type by direction")+": "+this.DirectionDescription() : property==ORDER_PROP_REASON ? TextByLanguage("Причина","Reason")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+this.GetReasonDescription(this.GetProperty(property)) ) : property==ORDER_PROP_POSITION_ID ? TextByLanguage("Идентификатор позиции","Position ID")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": #"+(string)this.GetProperty(property) ) : property==ORDER_PROP_DEAL_ORDER ? TextByLanguage("Сделка на основании ордера","Deal by order")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": #"+(string)this.GetProperty(property) ) : property==ORDER_PROP_DEAL_ENTRY ? TextByLanguage("Направление сделки","Deal direction")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+this.GetEntryDescription(this.GetProperty(property)) ) : property==ORDER_PROP_POSITION_BY_ID ? TextByLanguage("Идентификатор встречной позиции","Opposite position ID")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(string)this.GetProperty(property) ) : property==ORDER_PROP_TIME_OPEN_MSC ? TextByLanguage("Время открытия в милисекундах","Open time in milliseconds")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(string)this.GetProperty(property)+" > "+TimeMSCtoString(this.GetProperty(property)) ) : property==ORDER_PROP_TIME_CLOSE_MSC ? TextByLanguage("Время закрытия в милисекундах","Close time in milliseconds")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(string)this.GetProperty(property)+" > "+TimeMSCtoString(this.GetProperty(property)) ) : property==ORDER_PROP_TIME_UPDATE ? TextByLanguage("Время изменения позиции","Position change time")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(this.GetProperty(property)!=0 ? ::TimeToString(this.GetProperty(property),TIME_DATE|TIME_MINUTES|TIME_SECONDS) : "0") ) : property==ORDER_PROP_TIME_UPDATE_MSC ? TextByLanguage("Время изменения позиции в милисекундах","Position change time in milliseconds")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(this.GetProperty(property)!=0 ? (string)this.GetProperty(property)+" > "+TimeMSCtoString(this.GetProperty(property)) : "0") ) : property==ORDER_PROP_STATE ? TextByLanguage("Состояние","Statе")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": \""+this.StateDescription()+"\"" ) : //--- Propriedade adicional property==ORDER_PROP_STATUS ? TextByLanguage("Статус","Status")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": \""+this.StatusDescription()+"\"" ) : property==ORDER_PROP_PROFIT_PT ? TextByLanguage("Прибыль в пунктах","Profit in points")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(string)this.GetProperty(property) ) : property==ORDER_PROP_CLOSE_BY_SL ? TextByLanguage("Закрытие по StopLoss","Close by StopLoss")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(this.GetProperty(property) ? TextByLanguage("Да","Yes") : TextByLanguage("Нет","No")) ) : property==ORDER_PROP_CLOSE_BY_TP ? TextByLanguage("Закрытие по TakeProfit","Close by TakeProfit")+ (!this.SupportProperty(property) ? TextByLanguage(": Свойство не поддерживается",": Property not supported") : ": "+(this.GetProperty(property) ? TextByLanguage("Да","Yes") : TextByLanguage("Нет","No")) ) : "" ); } //+------------------------------------------------------------------+
Nós completamos todas as melhorias.
Deve-se ter em mente que a biblioteca está sendo desenvolvida "ao vivo" e ela é uma versão beta, portanto várias revisões, alterações e adições podem ser implementadas posteriormente.
Qual é o próximo?
No próximo artigo, eu vou desenvolver uma classe para uma seleção e classificação convenientes das ordens, negócios e posições por qualquer um dos critérios suportados e criar uma coleção de ordens à mercado e posições.
Todos os arquivos da versão atual da biblioteca estão anexados abaixo, juntamente com os arquivos de teste do EA para você testar e baixá-lo.
Deixe suas perguntas, comentários e sugestões nos comentários.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/5669
Estudo de técnicas de análise de velas (parte III): Biblioteca para trabalhar com os padrões
Extraindo dados estruturados de páginas HTML através de seletores CSS
Raspagem de dados da web sobre a rentabilidade dos títulos públicos
Biblioteca para desenvolvimento fácil e rápido de programas para a MetaTrader (parte I). Conceito, gerenciamento de dados e primeiros resultados
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso