MQLArticles/RM/AccountStatus.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                                AccountStatus.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_RM_ACCOUNTSTATUS_MQH

#define MQLARTICLES_RM_ACCOUNTSTATUS_MQH



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

#include "RM_Functions.mqh"

#include <Math/Stat/Stat.mqh>



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

#define ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_TP 1

#define ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_SL 2

#define ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_TP_SL (ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_TP|ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_SL)



//+------------------------------------------------------------------+

//| Global Variables                                                 |

//+------------------------------------------------------------------+

double account_status_curr_profit; // Profit en flotante - profit in float

bool   account_status_positions_open; // Flag indicating if there are open positions in the account



//+------------------------------------------------------------------+

//| Class for account management                                     |

//+------------------------------------------------------------------+

class CAccountStatus : public CManagerBase<CAccountGestor>

 {

private:

  //---

  CTicketsInfo*      open_positions; // CTicketsInfo type object for efficient ticket management

  bool               init;           // Flag indicating if it has been initialized correctly



  //---

  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



  //---

  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



  //---

  ROrder             last_order_struct;



  //--- Most recent structure of the opened or closed position

  ROnOpenClosePosition last_struct;



  // Variables that store a property of the last deal (when adding a deal, TRADE_TRANSACTION_DEAL_ADD)

  ulong              last_deal_ticket; // Ticket

  ENUM_DEAL_TYPE     last_deal_type;   // Deal type



  // Variable that stores the last symbol for specific events (TRADE_TRANSACTION_DEAL_ADD, TRADE_TRANSACTION_ORDER_DELETE)

  string             last_trans_symbol; // Symbol



  //--- Function to update profits

  void               UpdateProfitInit();

  void               UpdateProfit(const double& new_profit);



public:

                     CAccountStatus();

                    ~CAccountStatus();



  //--- Getter

  __forceinline Position GetPosition(ulong ticket) { return open_positions.GetByTicket(ticket); } // Get Position by ticket

  __forceinline int16_t  GetPositionsTotal() const  { return open_positions.Total(); } // Get total number of open positions

  __forceinline bool TheTicketExists(const ulong ticket) const { return open_positions.Exists(ticket); } // Check if ticket exists in positions array

  inline double      AccountGrossProfit() const {  return account_gross_profit; }

  inline double      AccountDailyProfit() const {  return account_daily_profit; }

  inline double      AccountWeeklyProfit() const {  return account_weekly_profit; }

  inline double      AccountMonthlyProfit() const {  return account_monthly_profit; }

  inline bool        IsInitialized() const { return init; }

  inline string      LastTransctionSymbol() const { return last_trans_symbol; }

  __forceinline      ROnOpenClosePosition LastStructPosition() const { return last_struct; }

  __forceinline      Position LastPosition() const { return last_struct.position; }



  //--- Events

  void               OnTradeTransactionEvent(const MqlTradeTransaction& trans); // Should be executed in OnTradeTransaction

  void               OnInitEvent(); // Should be executed in OnInit, at the end

  inline void        OnNewDay();    // The function should be called every new day

  inline void        OnNewWeek();   // The function should be called every new week

  inline void        OnNewMonth();  // The function should be called every new month



  //--- Ticket logs

  inline void        AddLogFlagTicket(uint8_t flags) { open_positions.AddLogFlags(flags); }

  inline void        RemoveLogFlagTicket(uint8_t flags) { open_positions.RemoveLogFlags(flags); }



  //--- Info functions

  void               PrintLastOrder();

  void               PrintLastPosition();

 };



//+------------------------------------------------------------------+

//| Constructor                                                      |

//+------------------------------------------------------------------+

CAccountStatus::CAccountStatus(void)

  : CManagerBase<CAccountGestor>(true), account_daily_profit(0.00), account_weekly_profit(0.00), account_gross_profit(0.00), account_monthly_profit(0.00), init(false)

 {

  account_status_curr_profit = 0.00;

  account_status_positions_open = false;

  open_positions = NULL;

  open_positions = new CTicketsInfo();

 }



//+------------------------------------------------------------------+

//| Destructor                                                       |

//+------------------------------------------------------------------+

CAccountStatus::~CAccountStatus()

 {

  if(open_positions != NULL)

    delete open_positions;

 }



//+------------------------------------------------------------------+

//| Function that executes every new day                             |

//+------------------------------------------------------------------+

inline void CAccountStatus::OnNewDay(void)

 {

  this.last_day_time = iTime(_Symbol, PERIOD_D1, 0);

  this.account_daily_profit = 0.0;

  for(int i = 0; i < total; i++)

    items[i].OnNewDay(this.last_day_time);

 }



//+------------------------------------------------------------------+

//| Function that executes every new month                           |

//+------------------------------------------------------------------+

inline void CAccountStatus::OnNewMonth(void)

 {

  this.last_monthly_time = iTime(_Symbol, PERIOD_MN1, 0);

  this.account_monthly_profit = 0.0;

  for(int i = 0; i < total; i++)

    items[i].OnNewMonth(this.last_monthly_time);

 }



//+------------------------------------------------------------------+

//| Function that executes weekly                                    |

//+------------------------------------------------------------------+

inline void CAccountStatus::OnNewWeek(void)

 {

  this.last_weekly_time = iTime(_Symbol, PERIOD_W1, 0);

  this.account_weekly_profit = 0.0;

  for(int i = 0; i < total; i++)

    items[i].OnNewWeek(this.last_weekly_time);

 }



//+------------------------------------------------------------------+

//| Function that executes in OnInit                                 |

//+------------------------------------------------------------------+

void CAccountStatus::OnInitEvent(void)

 {

//--- Initialize the profit collection variables

  this.last_day_time = iTime(_Symbol, PERIOD_D1, 0);

  this.last_weekly_time = iTime(_Symbol, PERIOD_W1, 0);

  this.last_monthly_time = iTime(_Symbol, PERIOD_MN1, 0);

  this.init = true;



//--- Initialize the managers with the new profit

  UpdateProfitInit();



//---

  ROnOpenClosePosition profit;

  profit.account_balance = AccountInfoDouble(ACCOUNT_BALANCE);

  profit.account_profit_diario = this.account_daily_profit;

  profit.account_profit_mensual = this.account_monthly_profit;

  profit.account_profit_semanal = this.account_weekly_profit;

  profit.account_profit_total = this.account_gross_profit;



  for(int i = 0; i < total; i++)

    items[i].OnNewProfit(profit);



//--- 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);



      //---

      Position new_pos;

      new_pos.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

      new_pos.ticket = position_ticket;

      new_pos.profit = GetTotalPositionProfitNoCurrent(position_ticket);

      new_pos.magic = (ulong)PositionGetInteger(POSITION_MAGIC);

      new_pos.tp = PositionGetDouble(POSITION_TP);

      new_pos.sl = PositionGetDouble(POSITION_SL);

      new_pos.open_time = (datetime)PositionGetInteger(POSITION_TIME);

      new_pos.open_price = PositionGetDouble(POSITION_PRICE_OPEN);

      new_pos.volume = PositionGetDouble(POSITION_VOLUME);

      open_positions.Add(new_pos);



      //---

      profit.position = new_pos;

      for(int k = 0; k < total; k++)

        items[k].OnInitNewPos(profit);

     }

   }

 }



//+------------------------------------------------------------------+

//| Function to update profits                                       |

//+------------------------------------------------------------------+

void               CAccountStatus::UpdateProfit(const double &new_profit)

 {

//---

  if(!init)

   {

    LogFatalError("CAccountStatus.OnInit must be called before executing any CAccountStatus function", FUNCION_ACTUAL);

    Remover();

    return;

   }



//---

  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);

   }



//---

  for(int i = 0; i < total; i++)

    items[i].OnLossProfit(new_profit);

 }



//+------------------------------------------------------------------+

void CAccountStatus::UpdateProfitInit()

 {

//---

  this.account_gross_profit = GetNetProfitSince(true, 0, D'1972.01.01 00:00');

  this.account_daily_profit = GetNetProfitSince(true, 0, this.last_day_time);

  this.account_weekly_profit = GetNetProfitSince(true, 0, this.last_weekly_time);

  this.account_monthly_profit = 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);

   }

 }



//+------------------------------------------------------------------+

//| Function to execute in OnTick                                    |

//+------------------------------------------------------------------+

#define CAccountStatus_OnTickEvent account_status_curr_profit = AccountInfoDouble(ACCOUNT_EQUITY) - AccountInfoDouble(ACCOUNT_BALANCE);





//+------------------------------------------------------------------+

//| 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(!EsUnaOrderPendiente[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;



        //---

        for(int i = 0; i < total; i++)

          items[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(!EsUnaOrderPendiente[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;