주시
1
0
포크
이미 MQLArticles을(를) 포크했습니다
0
원본 프로젝트 nique_372/MQLArticles
MQLArticles/Account/MoneyStatus/Manager.mqh
Nique_372 Nique_372 87640cc853
2026-11-07 21:17:58 -05:00
949 라인
34 KiB
MQL5
//+------------------------------------------------------------------+
//| Manager.mqh |
//| Copyright 2025, Niquel Mendoza. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Niquel Mendoza."
#property link "https://www.mql5.com"
#property strict
#ifndef MQLARTICLES_ACCOUNT_MONEYSTATUS_MANAGER_MQH
#define MQLARTICLES_ACCOUNT_MONEYSTATUS_MANAGER_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
// #define MQLARTICLES_RM_USE_HASHMAP_TICKESTABLE
#ifdef MQLARTICLES_RM_USE_HASHMAP_TICKESTABLE
#include "TicketsTable\\Heavy.mqh"
#else // MQLARTICLES_RM_USE_HASHMAP_TICKESTABLE
#include "TicketsTable\\Tiny.mqh"
//--- defines explicitos.. para mismo comportamiento esperado en ambos
#include <TSN\\GCol\\HashMap.mqh>
#include <TSN\\GCol\\GenericHashes.mqh>
#endif // MQLARTICLES_RM_USE_HASHMAP_TICKESTABLE
//#include <Math/Stat/Stat.mqh>
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//| Global Variables |
//+------------------------------------------------------------------+
bool account_status_positions_open = false; // Flag indicating if there are open positions in the account
CTicketsTable g_account_open_positions; // CTicketsTable type object for efficient ticket management
//+------------------------------------------------------------------+
//| Function to execute in OnTick |
//+------------------------------------------------------------------+
// Esta macro ah de ejecutarse en cada tick soloo cuando esta desactivado MQLARTICLES_RM_MULTI_EA_MODE
// Esta macro como tal es una "opt" que uso para en vez de recorrer todas las posiocnes de la cuenta sace el profit actual en un call-call
// Esta opt solo es valida si el EA opera solo... (Esto pro ahora solo se usa en CRiskManagement)
// De lo contraio si hay mas eas usar CalcProfit para solo contar las operaciones del EA
//--- 1.
#ifndef MQLARTICLES_RM_MULTI_EA_MODE
double account_status_curr_profit = 0.0; // Profit en flotante - profit in float
//---
#define ACCOUNTSTATUS_ONEVERYTICK TSN::account_status_curr_profit = (AccountInfoDouble(ACCOUNT_EQUITY) - AccountInfoDouble(ACCOUNT_BALANCE));
#endif // MQLARTICLES_RM_MULTI_EA_MODE
//+------------------------------------------------------------------+
//| Class for account management |
//+------------------------------------------------------------------+
class CAccountStatus : public CAllClassEventsBasic
{
private:
//--- Event Subscribers Arrays
CAccountGestor* m_on_close_position[];
int m_on_close_position_size;
CAccountGestor* m_on_open_position[];
int m_on_open_position_size;
CAccountGestor* m_on_position_modify[];
int m_on_position_modify_size;
CAccountGestor* m_on_order_add[];
int m_on_order_add_size;
CAccountGestor* m_on_order_update[];
int m_on_order_update_size;
CAccountGestor* m_on_order_delete[];
int m_on_order_delete_size;
CAccountGestor* m_on_new_profit[];
int m_on_new_profit_size;
CAccountGestor* m_on_withdrawal_deposit[];
int m_on_withdrawal_deposit_size;
CAccountGestor* m_on_init_new_pos[];
int m_on_init_new_pos_size;
CAccountGestor* m_on_loss_profit[];
int m_on_loss_profit_size;
//---
uint8_t m_flags;
public: // Publico (los last)
// SOLO LECTURA
// Si se modifica varias libs etc que depnden de esto pueden tener comportamiento indefinido (bugs, comportamiento silencioso etc..)
// Si hizo publico para acceso rapido y evitar overhead.. (RECUERDA)
//--- Most recent structure of the opened or closed position
// Orden
ROrder last_order_struct; // Ultima orden
// Posicion mas reicinte (en open\close\init) (deal buy\sell entry=in,out,outby y tambien posiciones iniciales)
ROnClosePosition last_struct; // Ultima posicion registrada
// Variable that stores the last symbol for specific events (TRADE_TRANSACTION_DEAL_ADD, TRADE_TRANSACTION_ORDER_DELETE)
string last_trans_symbol; // Ultimo Symbol
// Variables that store a property of the last deal (when adding a deal, TRADE_TRANSACTION_DEAL_ADD)
ulong last_deal_ticket; // Ultimo Ticket
ENUM_DEAL_TYPE last_deal_type; // Ultimo Deal type
ulong last_deal_magic; // Ultimo Magic
// Ultimos (init time)
datetime last_day_time; // Opening time of the current daily candle
datetime last_weekly_time; // Opening time of the current weekly candle
datetime last_monthly_time; // Opening time of the current monthly candle
// last
double account_daily_profit; // Account profit (adding EAs and user etc, total) daily
double account_weekly_profit; // Account profit (adding EAs and user etc, total) weekly
double account_monthly_profit; // Account profit (adding EAs and user etc, total) monthly
double account_gross_profit; // Account profit (adding EAs and user etc, total) total
private:
//--- Function to update profits
void UpdateProfitInit();
void UpdateProfit(const double new_profit);
public:
CAccountStatus();
~CAccountStatus();
//--- Event Registration Method
void RegisterEvents(CAccountGestor* ptr, uint flags);
void UnregisterEvents(CAccountGestor* ptr, uint flags);
void UnregisterEvent(CAccountGestor* ptr, const ENUM_TSNMQLART_ACCST_ETYPE event);
void RegisterEvent(CAccountGestor* ptr, const ENUM_TSNMQLART_ACCST_ETYPE event);
//--- Getter
//- Esta iniciado ?
__forceinline bool IsInitialized() const { return (m_flags & ACCOUNT_STATUS_FLAG_INIT) != 0; }
//- Aun esta activo?? (util para deinciacion en destrucotr de herederos de CAccountGestor)
__forceinline bool IsActive() const { return (m_flags & ACCOUNT_STATUS_FLAG_FREE) == 0; }
//--- Events
void OnTradeTransactionEvent(const MqlTradeTransaction& trans); // Should be executed in OnTradeTransaction
void OnInitEvent(); // Should be executed in OnInit, at the end
void OnNewDay(const datetime curr_time) override final; // The function should be called every new day
void OnNewWeek(const datetime curr_time) override final; // The function should be called every new week
void OnNewMonth(const datetime curr_time) override final; // The function should be called every new month
//--- Info functions
void PrintLastOrder();
void PrintLastPosition();
//---
void Deinit(const int reason);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CAccountStatus::CAccountStatus(void)
:
//---
account_daily_profit(0.00), account_weekly_profit(0.00), account_gross_profit(0.00), account_monthly_profit(0.00), m_flags(0),
//---
m_on_close_position_size(0), m_on_open_position_size(0), m_on_position_modify_size(0), m_on_order_add_size(0), m_on_order_update_size(0),
m_on_order_delete_size(0), m_on_new_profit_size(0), m_on_withdrawal_deposit_size(0), m_on_init_new_pos_size(0), m_on_loss_profit_size(0)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CAccountStatus::~CAccountStatus()
{
//Print("Entrando");
//CleanItems("AccountStatus");
// CBasicEvents::Unregister(CAllClassEventsBasic *ptr,const uchar flags) no tiene sentido. dado que es global...
// Entonces es eliminar cuando se elimina... asi que dejemos que mql5 haga loq eu tenga que hacer
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
__forceinline void CAccountStatus_Deinit(const int reason)
{
// WRapper para poder pasarlo
account_status.Deinit(reason);
}
//+------------------------------------------------------------------+
void CAccountStatus::Deinit(const int reason)
{
//--- Limpiamos todos los arrays
// SOlo ejecutamos en caso la clase solo tenga la benadera de incilzaicon
// En caso tenga otra bandera como free entonces no se ejeucta
if((m_flags & ACCOUNT_STATUS_FLAG_INIT) == ACCOUNT_STATUS_FLAG_INIT)
{
//---
m_on_close_position_size = 0;
m_on_open_position_size = 0;
m_on_position_modify_size = 0;;
m_on_order_add_size = 0;
m_on_order_update_size = 0;
m_on_order_delete_size = 0;
m_on_new_profit_size = 0;
m_on_withdrawal_deposit_size = 0;
m_on_init_new_pos_size = 0;
m_on_loss_profit_size = 0;
//---
m_flags |= ACCOUNT_STATUS_FLAG_FREE;
}
}
//+------------------------------------------------------------------+
//| Registro y De-Registro |
//+------------------------------------------------------------------+
void CAccountStatus::RegisterEvents(CAccountGestor* ptr, uint flags)
{
while(flags)
{
const uint flag_real = TSNTABLES_BIT_DEJAR_SOLO_MINUS_SIG_BYTE(flags);
const ENUM_TSNMQLART_ACCST_ETYPE type = (ENUM_TSNMQLART_ACCST_ETYPE)TSNTABLES_CTZ_32_GET_BIT(flag_real);
RegisterEvent(ptr, type);
flags &= ~flag_real;
}
}
//+------------------------------------------------------------------+
void CAccountStatus::RegisterEvent(CAccountGestor* ptr, const ENUM_TSNMQLART_ACCST_ETYPE event)
{
switch(event)
{
case TSNMQLART_ACCST_ETYPE_ON_OPEN_POSITION:
{
MANAGER_ARR_ADD(m_on_close_position, m_on_close_position_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_CLOSE_POSITION:
{
MANAGER_ARR_ADD(m_on_open_position, m_on_open_position_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_POSITION_MODIFY:
{
MANAGER_ARR_ADD(m_on_position_modify, m_on_position_modify_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_ADD:
{
MANAGER_ARR_ADD(m_on_order_add, m_on_order_add_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_UPDATE:
{
MANAGER_ARR_ADD(m_on_order_update, m_on_order_update_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_DELETE:
{
MANAGER_ARR_ADD(m_on_order_delete, m_on_order_delete_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_NEW_PROFIT:
{
MANAGER_ARR_ADD(m_on_new_profit, m_on_new_profit_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_WITHDRAWAL_DEPOSIT:
{
MANAGER_ARR_ADD(m_on_withdrawal_deposit, m_on_withdrawal_deposit_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_INIT_NEW_POS:
{
MANAGER_ARR_ADD(m_on_init_new_pos, m_on_init_new_pos_size, ptr)
break;
}
case TSNMQLART_ACCST_ETYPE_ON_LOSS_PROFIT:
{
MANAGER_ARR_ADD(m_on_loss_profit, m_on_loss_profit_size, ptr)
break;
}
default:
break;
}
}
//+------------------------------------------------------------------+
//| De-Suscribirse |
//+------------------------------------------------------------------+
void CAccountStatus::UnregisterEvents(CAccountGestor* ptr, uint flags)
{
while(flags)
{
const uint flag_real = TSNTABLES_BIT_DEJAR_SOLO_MINUS_SIG_BYTE(flags);
const ENUM_TSNMQLART_ACCST_ETYPE type = (ENUM_TSNMQLART_ACCST_ETYPE)TSNTABLES_CTZ_32_GET_BIT(flag_real);
UnregisterEvent(ptr, type);
flags &= ~flag_real;
}
}
//+------------------------------------------------------------------+
void CAccountStatus::UnregisterEvent(CAccountGestor* ptr, const ENUM_TSNMQLART_ACCST_ETYPE event)
{
switch(event)
{
case TSNMQLART_ACCST_ETYPE_ON_OPEN_POSITION:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_open_position, m_on_open_position_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_CLOSE_POSITION:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_close_position, m_on_close_position_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_POSITION_MODIFY:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_position_modify, m_on_position_modify_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_ADD:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_order_add, m_on_order_add_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_UPDATE:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_order_update, m_on_order_update_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_ORDER_DELETE:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_order_delete, m_on_order_delete_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_NEW_PROFIT:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_new_profit, m_on_new_profit_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_WITHDRAWAL_DEPOSIT:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_withdrawal_deposit, m_on_withdrawal_deposit_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_INIT_NEW_POS:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_init_new_pos, m_on_init_new_pos_size, ptr);
break;
}
case TSNMQLART_ACCST_ETYPE_ON_LOSS_PROFIT:
{
TSNMQLArtUtilsMan_RemoveFromArrayFast(m_on_loss_profit, m_on_loss_profit_size, ptr);
break;
}
default:
break;
}
}
//+------------------------------------------------------------------+
//| Function that executes every new day |
//+------------------------------------------------------------------+
void CAccountStatus::OnNewDay(const datetime curr_time)
{
this.last_day_time = curr_time - (curr_time % 86400u);
this.account_daily_profit = 0.0;
}
//+------------------------------------------------------------------+
//| Function that executes every new month |
//+------------------------------------------------------------------+
void CAccountStatus::OnNewMonth(const datetime curr_time)
{
if((m_flags & ACCOUNT_STATUS_FLAG_INIT) == 0)
{
LogError("Account status no INICIADO", FUNCION_ACTUAL);
Remover();
return;
}
this.last_monthly_time = curr_time;
this.account_monthly_profit = 0.0;
}
//+------------------------------------------------------------------+
//| Function that executes weekly |
//+------------------------------------------------------------------+
void CAccountStatus::OnNewWeek(const datetime curr_time)
{
this.last_weekly_time = curr_time;
this.account_weekly_profit = 0.0;
}
//+------------------------------------------------------------------+
//| Function that executes in OnInit |
//+------------------------------------------------------------------+
void CAccountStatus::OnInitEvent()
{
//---
if((m_flags & ACCOUNT_STATUS_FLAG_INIT) != 0)
{
LogWarning("Clase ya iniciada", FUNCION_ACTUAL);
return;
}
//---
const datetime curr_time = TimeCurrent();
//--- Initialize the profit collection variables
this.last_day_time = curr_time - (curr_time % 86400u);
this.last_weekly_time = CTimeUtils::StartOfWeek(curr_time);
this.last_monthly_time = CTimeUtils::StartOfMonth(curr_time);
this.m_flags |= ACCOUNT_STATUS_FLAG_INIT;
//--- Registramos para que reciba el evento
CBasicEvents::Register(&this, BASICEVENT_REG_ALL_FLAG);
//--- Initialize the managers with the new profit
UpdateProfitInit();
//--- Notify OnNewProfit subscribers
for(int i = 0; i < m_on_new_profit_size; i++)
m_on_new_profit[i].OnNewProfit(curr_time);
//--- Check if there are open trades
const int pos_total = PositionsTotal();
//--- If there are open positions we add them
if(pos_total > 0)
{
for(int i = pos_total - 1; i >= 0; i--)
{
const ulong position_ticket = PositionGetTicket(i);
if(!PositionSelectByTicket(position_ticket))
continue;
//---
last_trans_symbol = PositionGetString(POSITION_SYMBOL);
//---
last_struct.position.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
last_struct.position.ticket = position_ticket;
last_struct.position.profit = CHistoryMoneyUtils::GetTotalPositionProfitNoCurrent(position_ticket);
last_struct.position.magic = (ulong)PositionGetInteger(POSITION_MAGIC);
last_struct.position.tp = PositionGetDouble(POSITION_TP);
last_struct.position.sl = PositionGetDouble(POSITION_SL);
last_struct.position.open_time = (datetime)PositionGetInteger(POSITION_TIME);
last_struct.position.open_price = PositionGetDouble(POSITION_PRICE_OPEN);
last_struct.position.volume = PositionGetDouble(POSITION_VOLUME);
//---
g_account_open_positions.Add(last_struct.position);
//--- Notify OnInitNewPos subscribers
for(int k = 0; k < m_on_init_new_pos_size; k++)
m_on_init_new_pos[k].OnInitNewPos(last_struct);
}
}
}
//+------------------------------------------------------------------+
//| Function to update profits |
//+------------------------------------------------------------------+
void CAccountStatus::UpdateProfit(const double new_profit)
{
//---
this.account_gross_profit += new_profit;
this.account_daily_profit += new_profit;
this.account_weekly_profit += new_profit;
this.account_monthly_profit += new_profit;
//---
if(IsInfoLogEnabled())
{
FastLog(FUNCION_ACTUAL, INFO_TEXT, "New profits:");
Print("Daily profit: ", this.account_daily_profit);
Print("Weekly profit: ", this.account_weekly_profit);
Print("Monthly profit: ", this.account_monthly_profit);
Print("Gross profit: ", this.account_gross_profit);
}
//--- Notify OnLossProfit subscribers
for(int i = 0; i < m_on_loss_profit_size; i++)
m_on_loss_profit[i].OnLossProfit(new_profit);
}
//+------------------------------------------------------------------+
void CAccountStatus::UpdateProfitInit()
{
//---
this.account_gross_profit = CHistoryMoneyUtils::GetNetProfitSince(true, 0, D'1972.01.01 00:00');
this.account_daily_profit = CHistoryMoneyUtils::GetNetProfitSince(true, 0, this.last_day_time);
this.account_weekly_profit = CHistoryMoneyUtils::GetNetProfitSince(true, 0, this.last_weekly_time);
this.account_monthly_profit = CHistoryMoneyUtils::GetNetProfitSince(true, 0, this.last_monthly_time);
//---
if(IsInfoLogEnabled())
{
FastLog(FUNCION_ACTUAL, INFO_TEXT, "New profits:");
Print("Daily profit: ", this.account_daily_profit);
Print("Weekly profit: ", this.account_weekly_profit);
Print("Monthly profit: ", this.account_monthly_profit);
Print("Gross profit: ", this.account_gross_profit);
}
}
//+------------------------------------------------------------------+
//| OnTradeTransaction event |
//+------------------------------------------------------------------+
//--- Activa el evento de OnOrderAdd
//#define CACCOUNT_STATUS_ACTIVE_ON_ORDER_ADD
//--- Activa el evento de OnOrderUpdate
//#define CACCOUNT_STATUS_ACTIVE_ON_ORDER_UPDATE
//--- Activa el evento de OnOrderDelete
//#define CACCOUNT_STATUS_ACTIVE_ON_ORDER_DELETE
//--- Activa el evento de OnPositionModifed
//#define CACCOUNT_STATUS_ACTIVE_ON_POSITION_MODIFIED
//--- En los evenots de ordenes, su definicion activa que tamiben cuenten las ordenes de compra y venta
//#define CACCOUNT_STATUS_COUNT_ORDERS_BUY_SELL
//---
void CAccountStatus::OnTradeTransactionEvent(const MqlTradeTransaction &trans)
{
//---
switch(trans.type)
{
//---
case TRADE_TRANSACTION_ORDER_ADD: // 0
{
#ifdef CACCOUNT_STATUS_ACTIVE_ON_ORDER_ADD
#ifndef CACCOUNT_STATUS_COUNT_ORDERS_BUY_SELL
if(!MQLArticles_IsPendingOrder(trans.order_type))
return;
#endif // CACCOUNT_STATUS_COUNT_ORDERS_BUY_SELL
//---
if(OrderSelect(trans.order))
{
//---
last_trans_symbol = trans.symbol;
//---
last_order_struct.order_open_price = trans.price;
last_order_struct.order_stop_loss = trans.price_sl;
last_order_struct.order_take_profit = trans.price_tp;
last_order_struct.order_magic = OrderGetInteger(ORDER_MAGIC);
last_order_struct.order_ticket = trans.order;
last_order_struct.order_time_expiration = trans.time_expiration;
last_order_struct.order_reason = (ENUM_ORDER_REASON)OrderGetInteger(ORDER_REASON);
last_order_struct.order_type = trans.order_type;
last_order_struct.order_state = trans.order_state;
last_order_struct.order_type_time = trans.time_type;
//--- Notify OnOrderAdd subscribers
for(int i = 0; i < m_on_order_add_size; i++)
m_on_order_add[i].OnOrderAdd(last_order_struct);
}
else
{
LogError(StringFormat("Error al seleccionar la orden %I64u", trans.order), FUNCION_ACTUAL);
}
#endif // CACCOUNT_STATUS_ACTIVE_ON_ORDER_ADD
//---
break;
}
//---
case TRADE_TRANSACTION_ORDER_UPDATE: // 1
{
#ifdef CACCOUNT_STATUS_ACTIVE_ON_ORDER_UPDATE
#ifndef CACCOUNT_STATUS_COUNT_ORDERS_BUY_SELL
if(!MQLArticles_IsPendingOrder(trans.order_type))
return;
#endif // CACCOUNT_STATUS_COUNT_ORDERS_BUY_SELL
//---
if(OrderSelect(trans.order))
{
//---
last_trans_symbol = trans.symbol;
//---
last_order_struct.order_open_price = trans.price;
last_order_struct.order_stop_loss = trans.price_sl;
last_order_struct.order_take_profit = trans.price_tp;
last_order_struct.order_magic = OrderGetInteger(ORDER_MAGIC);
last_order_struct.order_ticket = trans.order;
last_order_struct.order_time_expiration = trans.time_expiration;
last_order_struct.order_reason = (ENUM_ORDER_REASON)OrderGetInteger(ORDER_REASON);
last_order_struct.order_type = trans.order_type;
last_order_struct.order_state = trans.order_state;
last_order_struct.order_type_time = trans.time_type;
//--- Notify OnOrderUpdate subscribers
for(int i = 0; i < m_on_order_update_size; i++)
m_on_order_update[i].OnOrderUpdate(last_order_struct);
}
else
{
LogError(StringFormat("Error al seleccionar la orden %I64u", trans.order), FUNCION_ACTUAL);
}
#endif // CACCOUNT_STATUS_ACTIVE_ON_ORDER_UPDATE
//---
break;
}
//---
case TRADE_TRANSACTION_ORDER_DELETE: // 2
{
//---
break;
}
//---
case TRADE_TRANSACTION_HISTORY_ADD: // 3
{
#ifdef CACCOUNT_STATUS_ACTIVE_ON_ORDER_DELETE
//---
if(MQLArticles_IsPendingOrder(trans.order_type))
{
if(HistoryOrderSelect(trans.order))
{
// Se llama antes que historyadd
//---
last_trans_symbol = trans.symbol;
//---
last_order_struct.order_open_price = trans.price;
last_order_struct.order_stop_loss = trans.price_sl;
last_order_struct.order_take_profit = trans.price_tp;
last_order_struct.order_magic = HistoryOrderGetInteger(trans.order, ORDER_MAGIC);
last_order_struct.order_ticket = trans.order;
last_order_struct.order_time_expiration = trans.time_expiration;
last_order_struct.order_reason = (ENUM_ORDER_REASON)HistoryOrderGetInteger(trans.order, ORDER_REASON);
last_order_struct.order_type = trans.order_type;
last_order_struct.order_state = trans.order_state;
last_order_struct.order_type_time = trans.time_type;
//--- Notify OnOrderDelete subscribers
for(int i = 0; i < m_on_order_delete_size; i++)
m_on_order_delete[i].OnOrderDelete(last_order_struct);
}
else
{
LogError(StringFormat("Error al seleccionar la orden %I64u", trans.order), FUNCION_ACTUAL);
}
}
#endif // CACCOUNT_STATUS_ACTIVE_ON_ORDER_DELETE
break;
}
//---
case TRADE_TRANSACTION_HISTORY_UPDATE: // 4
{
break;
}
//---
case TRADE_TRANSACTION_HISTORY_DELETE: // 5
{
break;
}
//---
case TRADE_TRANSACTION_DEAL_ADD: // 6
{
//---
last_deal_type = trans.deal_type;
last_deal_ticket = trans.deal;
last_trans_symbol = trans.symbol;
//---
if(TSNMQLART_MONEYHIST_DEALIS_COMPRAVENTA(last_deal_type))
{
HistoryDealSelect(trans.deal);
//---
const ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(last_deal_ticket, DEAL_ENTRY);
last_deal_magic = (ulong)HistoryDealGetInteger(last_deal_ticket, DEAL_MAGIC);
const ulong position_ticket = trans.position;
//---
const double deal_profit = HistoryDealGetDouble(last_deal_ticket, DEAL_PROFIT); // Get deal profit
const double deal_commission = HistoryDealGetDouble(last_deal_ticket, DEAL_COMMISSION); // Get commission
//---
if(entry == DEAL_ENTRY_IN)
{
if(!PositionSelectByTicket(trans.position))
break;
//---
LogInfo(StringFormat("Position %I64u opened with magic %I64u", position_ticket, last_deal_magic), FUNCION_ACTUAL);
//--- Activate open positions flag
account_status_positions_open = true;
//--- Calculate the profit
const double deal_net_profit = deal_profit + deal_commission; // Calculate net profit
UpdateProfit(deal_net_profit); //Update the profit
//--- Create a new position to add to the tickets
last_struct.position.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
last_struct.position.ticket = position_ticket;
last_struct.position.magic = last_deal_magic;
last_struct.position.profit = deal_net_profit;
last_struct.position.open_time = (datetime)PositionGetInteger(POSITION_TIME);
last_struct.position.open_price = trans.price;
last_struct.position.sl = trans.price_sl;
last_struct.position.tp = trans.price_tp;
last_struct.position.volume = trans.volume;
//--- Add to positions array
g_account_open_positions.Add(last_struct.position);
//--- Extra
// Deal
last_struct.deal_entry_type = entry;
last_struct.deal_ticket = last_deal_ticket;
last_struct.deal_profit = deal_net_profit;
last_struct.deal_reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(last_deal_ticket, DEAL_REASON);
// Extra
last_struct.magic_number_closed = 0;
//--- Notify OnOpenClosePosition subscribers
for(int i = 0; i < m_on_open_position_size; i++)
m_on_open_position[i].OnOpenPosition(last_struct);
}
else
if((entry & 1) == 1) // out + outby
{
int pos_idx;
if(g_account_open_positions.GetByTicket(position_ticket, last_struct.position, pos_idx))
{
//---
if((last_struct.position.volume - trans.volume) < ACCOUNT_STATUS_MIN_VOL) // Cierre completo
{
//---
g_account_open_positions.DeleteByIndex(pos_idx);
//---
LogCaution(StringFormat("Position with ticket %I64u has been closed", position_ticket), FUNCION_ACTUAL);
//--- Get the most recent profit
const double deal_swap = HistoryDealGetDouble(last_deal_ticket, DEAL_SWAP); // Get swap fees
const double deal_net_profit = deal_profit + deal_commission + deal_swap; // Calculate net profit
//---
if(g_account_open_positions.Count() == 0)
account_status_positions_open = false;
//--- Update its profit
last_struct.position.profit += deal_net_profit;
//--- Update the general profit
UpdateProfit(deal_net_profit);
//--- Set the new structure
// Ya se hace
// Deal
last_struct.deal_entry_type = entry; //market entry type (ENTRY_OUT)
last_struct.deal_ticket = last_deal_ticket; //Closing deal ticket
last_struct.deal_profit = deal_net_profit; //Net profit (excluding commissions)
last_struct.deal_reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(last_deal_ticket, DEAL_REASON);
// Extra
last_struct.magic_number_closed = last_deal_magic; //Ticket with which the position was closed
//--- Notify OnOpenClosePosition subscribers
for(int i = 0; i < m_on_close_position_size; i++)
m_on_close_position[i].OnClosePosition(last_struct, pos_idx);
}
else // Cierre parcial
{
//---
LogCaution(StringFormat("Possible partial closure of the position: %I64u", position_ticket), FUNCION_ACTUAL);
//---
const double deal_swap = HistoryDealGetDouble(last_deal_ticket, DEAL_SWAP); // Get swap fees
const double deal_net_profit = deal_profit + deal_commission + deal_swap; // Calculate net profit
//---
g_account_open_positions.UpdatePositionPartial(deal_net_profit, trans.volume, pos_idx); //Update the profit of the position that partially closed
//---
UpdateProfit(deal_net_profit);
}
}
// else: No existe (posible bug pero bueno)
// por ahora tampoco manejo el otro tipo de inout
}
}
else
if(last_deal_type == DEAL_TYPE_BALANCE || last_deal_type == DEAL_TYPE_CHARGE) // Withdrawal or deposit
{
HistoryDealSelect(last_deal_ticket);
const double deal_profit = HistoryDealGetDouble(last_deal_ticket, DEAL_PROFIT); // Get deal profit
//---
if(fabs(deal_profit) < ACCOUNT_STATUS_MIN_VOL)
break;
//--- Notify OnWithdrawalDeposit subscribers
for(int i = 0; i < m_on_withdrawal_deposit_size; i++)
m_on_withdrawal_deposit[i].OnWithdrawalDeposit(deal_profit);
}
// Otros deals: se ignoran
//---
break;
}
//---
case TRADE_TRANSACTION_DEAL_UPDATE: // 7
{
break;
}
//---
case TRADE_TRANSACTION_DEAL_DELETE: // 8
{
break;
}
//---
case TRADE_TRANSACTION_POSITION: // 9
{
#ifdef CACCOUNT_STATUS_ACTIVE_ON_POSITION_MODIFIED
const ulong t = trans.position;
if(g_account_open_positions.GetByTicket(t, last_struct.position))
{
//---
last_trans_symbol = trans.symbol;
//---
uint8_t f = 0;
//--- Cambio tp
const double new_tp = trans.price_tp;
if(last_struct.position.tp != new_tp)
{
g_account_open_positions.UpdateTp(new_tp, t);
last_struct.position.tp = new_tp;
f |= ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_TP;
}
//--- Cambio sl
const double new_sl = trans.price_sl;
if(last_struct.position.sl != new_sl)
{
g_account_open_positions.UpdateSl(new_sl, t);
last_struct.position.sl = new_sl;
f |= ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_SL;
}
//--- Notify OnPositionModify subscribers
if(f)
for(int i = 0; i < m_on_position_modify_size; i++)
m_on_position_modify[i].OnPositionModify(last_struct.position, f);
}
#endif // CACCOUNT_STATUS_ACTIVE_ON_POSITION_MODIFIED
break;
}
//---
case TRADE_TRANSACTION_REQUEST: // 10
{
break;
}
}
}
//+------------------------------------------------------------------+
//| Print last order values |
//+------------------------------------------------------------------+
void CAccountStatus::PrintLastOrder(void)
{
Print("--- Last Order ---");
Print("Ticket: ", last_order_struct.order_ticket);
Print("Type: ", EnumToString(last_order_struct.order_type));
Print("State: ", EnumToString(last_order_struct.order_state));
Print("Magic: ", last_order_struct.order_magic);
Print("Open Price: ", last_order_struct.order_open_price);
Print("Stop Loss: ", last_order_struct.order_stop_loss);
Print("Take Profit: ", last_order_struct.order_take_profit);
Print("Expiration: ", last_order_struct.order_time_expiration);
Print("Time Type: ", EnumToString(last_order_struct.order_type_time));
Print("Reason: ", EnumToString(last_order_struct.order_reason));
}
//+------------------------------------------------------------------+
//| Print last position values |
//+------------------------------------------------------------------+
void CAccountStatus::PrintLastPosition(void)
{
Print("--- Last Position ---");
Print("Ticket: ", last_struct.position.ticket);
Print("Type: ", EnumToString(last_struct.position.type));
Print("Magic: ", last_struct.position.magic);
Print("Open Price: ", last_struct.position.open_price);
Print("Open Time: ", last_struct.position.open_time);
Print("Stop Loss: ", last_struct.position.sl);
Print("Take Profit: ", last_struct.position.tp);
Print("Profit: ", last_struct.position.profit);
}
//---
// Nota importante:
// En versiones antiguas los obejtos agregados (regisrados) SE ELIMINABAN de la clase.. ahora YA NO
// La clase ya no gestiona los LOGS NI elimina los obejtos agregados a ella, solo da los eventos
CAccountStatus account_status;
}
#endif // MQLARTICLES_ACCOUNT_MONEYSTATUS_MANAGER_MQH
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+