| //+------------------------------------------------------------------+
|
| //| 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;
|
| 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].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(EsUnaOrderPendiente[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;
|
|
|
| //---
|
| for(int i = 0; i < total; i++)
|
| items[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(last_deal_type == DEAL_TYPE_BUY || last_deal_type == DEAL_TYPE_SELL)
|
| {
|
| HistoryDealSelect(trans.deal);
|
| const ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(last_deal_ticket, DEAL_ENTRY);
|
| const ulong 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(PositionSelectByTicket(trans.position) && entry == DEAL_ENTRY_IN)
|
| {
|
| //---
|
| LogInfo(StringFormat("Position %I64u opened with magic %I64u", position_ticket, 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
|
|
|
| //--- Create a new position to add to the tickets
|
| Position new_pos;
|
| new_pos.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
| new_pos.ticket = position_ticket;
|
| new_pos.magic = deal_magic;
|
| new_pos.profit = deal_net_profit;
|
| new_pos.open_time = (datetime)PositionGetInteger(POSITION_TIME);
|
| new_pos.open_price = trans.price;
|
| new_pos.sl = trans.price_sl;
|
| new_pos.tp = trans.price_tp;
|
| new_pos.volume = trans.volume;
|
|
|
| //---
|
| UpdateProfit(deal_net_profit); //Update the profit
|
|
|
| //--- Add to positions array
|
| open_positions.Add(new_pos);
|
|
|
| //--- Set the new structure
|
| last_struct.position = new_pos;
|
|
|
| // Account
|
| last_struct.account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
| last_struct.account_profit_diario = account_daily_profit;
|
| last_struct.account_profit_total = account_gross_profit;
|
| last_struct.account_profit_mensual = account_monthly_profit;
|
| last_struct.account_profit_semanal = account_weekly_profit;
|
|
|
| // 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;
|
|
|
| //---
|
| for(int i = 0; i < total; i++)
|
| items[i].OnOpenClosePosition(last_struct);
|
|
|
| //---
|
| return;
|
| }
|
|
|
| if(entry != DEAL_ENTRY_OUT)
|
| break;
|
|
|
| //---
|
| #define ACCOUNT_STATUS_MIN_VOL 0.00000001
|
|
|
| //---
|
| int16_t pos_idx;
|
| if(open_positions.GetByTicket(position_ticket, last_struct.position, pos_idx))
|
| {
|
| // Print("Vol: ", DoubleToString(trans.volume));
|
|
|
| //---
|
| if((last_struct.position.volume - trans.volume) < ACCOUNT_STATUS_MIN_VOL) // Cierre completo
|
| {
|
| //---
|
| 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(GetPositionsTotal() == 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
|
|
|
| // Account
|
| last_struct.account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
| last_struct.account_profit_diario = account_daily_profit;
|
| last_struct.account_profit_total = account_gross_profit;
|
| last_struct.account_profit_mensual = account_monthly_profit;
|
| last_struct.account_profit_semanal = account_weekly_profit;
|
|
|
| // 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 = deal_magic; //Ticket with which the position was closed
|
|
|
| //--- Execute in the inheritors
|
| for(int i = 0; i < total; i++)
|
| items[i].OnOpenClosePosition(last_struct);
|
|
|
| //---
|
| break;
|
| }
|
| else
|
| {
|
| //---
|
| 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
|
|
|
| //---
|
| open_positions.UpdatePositionPartial(deal_net_profit, trans.volume, pos_idx); //Update the profit of the position that partially closed
|
|
|
| //---
|
| UpdateProfit(deal_net_profit);
|
|
|
| //---
|
| break;
|
| }
|
|
|
| //---
|
| break;
|
| }
|
| }
|
| 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) < 0.0000000001)
|
| break;
|
|
|
| //---
|
| for(int i = 0; i < total; i++)
|
| items[i].OnWithdrawalDeposit(deal_profit);
|
|
|
| //---
|
| break;
|
| }
|
|
|
| //---
|
| 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(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)
|
| {
|
| 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)
|
| {
|
| open_positions.UpdateSl(new_sl, t);
|
| last_struct.position.sl = new_sl;
|
| f |= ACCOUNTSTATUS_ON_POS_MODIFY_FLAG_CHANGE_SL;
|
| }
|
|
|
| //---
|
| if(f)
|
| for(int i = 0; i < total; i++)
|
| items[i].OnPositionModify(last_struct.position, f);
|
| }
|
| #endif // CACCOUNT_STATUS_ACTIVE_ON_POSITION_MODIFIED
|
| break;
|
| }
|
|
|
| //---
|
| case TRADE_TRANSACTION_REQUEST: // 10
|
| {
|
| break;
|
| }
|
|
|
| //---
|
| default:
|
| 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);
|
| }
|
|
|
|
|
| /*
|
| ADVERTENCIA: Si se añaden items a esta clase, esta las eliminara por defecto, NO propagara sus logs.. solko funcioan como container
|
| WARNING: If items are added to this class, it will delete them by default, it will NOT propagate their logs. They only function as containers.
|
| */
|
|
|
| CAccountStatus account_status;
|
| #endif // MQLARTICLES_RM_ACCOUNTSTATUS_MQH
|
| //+------------------------------------------------------------------+
|
|
|
| //+------------------------------------------------------------------+
|