AiDataTaskRuner/Backend/Mcp/Functions.mqh

//+------------------------------------------------------------------+
//|                                                    Functions.mqh |
//|                                  Copyright 2026, Niquel Mendoza. |
//|                          https://www.mql5.com/es/users/nique_372 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link      "https://www.mql5.com/es/users/nique_372"
#property strict

#ifndef AIDATATASKRUNNER_BACKEND_MCP_FUNCTIONS_MQH
#define AIDATATASKRUNNER_BACKEND_MCP_FUNCTIONS_MQH

//+------------------------------------------------------------------+
//| Include                                                          |
//+------------------------------------------------------------------+
#include <TSN\\Mcp\\Main.mqh>
#include <TSN\\MQLArticles\\Utils\\EnumReg.mqh>
#include "..\\Api\\Protocol\\Def.mqh"

//+------------------------------------------------------------------+
//| Base comun para todas las funciones async de AiDataTaskRunner    |
//+------------------------------------------------------------------+
namespace TSN
{
class CMcpFuncAiTaskRunnerBase : public CMcpFunction
 {
protected:
  //--- Miembros
  const long         m_chart_id_panel;
  const long         m_current_chart_id;

  //--- Funciones
  bool               DispatchToPanel(const uint8_t event_id, const string val);
  bool               TryUnpack(const string& sparam, string& val);
  void               SendResult(const double dparam, const string& val);

public:
                     CMcpFuncAiTaskRunnerBase(const string& func_name, const long chart_id_panel, const long curr_chart_id)
    :                CMcpFunction(MCPSERVERBYLEO_FLAG_CHARTEVENT, true, func_name),
                      m_chart_id_panel(chart_id_panel), m_current_chart_id(curr_chart_id)
   {}
                    ~CMcpFuncAiTaskRunnerBase(void) {}
 };

//+------------------------------------------------------------------+
bool CMcpFuncAiTaskRunnerBase::DispatchToPanel(const uint8_t event_id, const string val)
 {
  if(!::EventChartCustom(m_chart_id_panel, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                         m_current_chart_id, double(event_id),
                         AiDataTaskRunnerEmpaquetar("mcp_server_aidata", val)))
   {
    m_shared_builder.PutChar('"');
    m_shared_builder.Obj();
    m_shared_builder.KeyWV("ok").Val(false);
    m_shared_builder.KeyWV("error").ValSWV("dispatch_failed");
    m_shared_builder.EndObj();
    m_shared_builder.PutChar('"');
    return false;
   }
  return true;
 }

//+------------------------------------------------------------------+
bool CMcpFuncAiTaskRunnerBase::TryUnpack(const string& sparam, string& val)
 {
  static string id_call_recv;
  if(!AiDataTaskRunnerDesempaquetar(sparam, id_call_recv, val))
    return false;
  return true;
 }

//+------------------------------------------------------------------+
//| SendResult - Arma el JSON de respuesta async y lo despacha       |
//+------------------------------------------------------------------+
void CMcpFuncAiTaskRunnerBase::SendResult(const double dparam, const string& val)
 {
//---
  m_shared_builder.PutChar('"');
  m_shared_builder.Obj();
  m_shared_builder.KeyWV("ok").Val(dparam == AIDATATASKRUNER_API_RES_EXITO);
  m_shared_builder.KeyWV("result").ValS(val);
  m_shared_builder.EndObj();
  m_shared_builder.PutChar('"');
  m_mcp_server._RecibedEvent(m_shared_builder);
 }

//+------------------------------------------------------------------+
//| get_task_total                                                   |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerGetTaskTotal : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerGetTaskTotal(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_get_task_total", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerGetTaskTotal(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_TASK_TOTAL, "");
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_TASK_TOTAL)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| get_task_by_index                                                |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerGetTaskByIndex : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerGetTaskByIndex(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_get_task_by_index", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerGetTaskByIndex(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_GET_TASK_BY_INDEX, param["index"].ToString());
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_GET_TASK_BY_INDEX)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| get_task_status                                                  |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerGetTaskStatus : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerGetTaskStatus(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_get_task_status", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerGetTaskStatus(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_GET_TASK_STATUS, param["index"].ToString());
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_GET_TASK_STATUS)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| get_main_folder                                                  |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerGetMainFolder : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerGetMainFolder(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_get_main_folder", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerGetMainFolder(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_MAIN_FOLDER, "");
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_MAIN_FOLDER)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| get_task_folder                                                  |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerGetTaskFolder : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerGetTaskFolder(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_get_task_folder", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerGetTaskFolder(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_TASK_FOLDER, "");
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_TASK_FOLDER)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| is_in_commonfolder                                               |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerIsInCommonFolder : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerIsInCommonFolder(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_is_in_commonfolder", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerIsInCommonFolder(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_IS_IN_COMMON_FOLDER, "");
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_IS_IN_COMMON_FOLDER)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| clean_all_tasks                                                  |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerCleanAllTasks : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerCleanAllTasks(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_clean_all_tasks", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerCleanAllTasks(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_CLEAN_ALL_TASK_OF_TABLE, "");
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_CLEAN_ALL_TASK_OF_TABLE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| load_tasks_from_file                                             |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerLoadTasksFromFile : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerLoadTasksFromFile(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_load_tasks_from_file", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerLoadTasksFromFile(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_LOAD_TASK_IN_FILE, param["file_name"].ToString());
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_LOAD_TASK_IN_FILE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| save_tasks_to_file                                               |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerSaveTasksToFile : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerSaveTasksToFile(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_save_tasks_to_file", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerSaveTasksToFile(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    const string val = StringFormat("%d|%s", int(param["only_unfinished"].ToBool(false)), param["file_name"].ToString());
    DispatchToPanel(AIDATATASKRUNER_API_SAVE_TASK_IN_FILE, val);
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_SAVE_TASK_IN_FILE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| load_config                                                      |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerLoadConfig : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerLoadConfig(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_load_config", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerLoadConfig(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_LOAD_CONFIG_IN_FILE, param["file_name"].ToString());
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_LOAD_CONFIG_IN_FILE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| save_config                                                      |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerSaveConfig : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerSaveConfig(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_save_config", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerSaveConfig(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    DispatchToPanel(AIDATATASKRUNER_API_SAVE_CONFIG_IN_FILE, param["file_name"].ToString());
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_SAVE_CONFIG_IN_FILE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| add_task                                                         |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerAddTask : public CMcpFuncAiTaskRunnerBase
 {
public:
                     CMcpFuncAiTaskRunnerAddTask(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFuncAiTaskRunnerBase("aidatataskrunner_add_task", chart_id_panel, curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerAddTask(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;

    //---
    const int timeframe = CEnumRegBasis::GetValNoRef<int>(param["timeframe"].ToString("_Period"), _Period);
    const string val = StringFormat("%d|%s|%s|%s|%s|%s|%s|%s",
                                    timeframe,
                                    param["symbol"].ToString(),
                                    param["set_file"].ToString(""),
                                    param["start_date"].ToString(),
                                    param["end_date"].ToString(),
                                    param["symbol_folder"].ToString(""),
                                    param["label"].ToString(""),
                                    param["label_id"].ToString("0"));
    DispatchToPanel(AIDATATASKRUNER_API_ADD_TASK_TO_TABLE, val);
   }

  //---
  void               ChartEvent(const int32_t id, const long& lparam, const double& dparam, const string& sparam) override final
   {
    if(id != CHARTEVENT_CUSTOM + AIDATATASKRUNER_API_ON_PARAM_CHANGE)
      return;
    if(lparam != AIDATATASKRUNER_API_ADD_TASK_TO_TABLE)
      return;
    static string val;
    if(!TryUnpack(sparam, val))
      return;
    SendResult(dparam, val);
   }
 };

//+------------------------------------------------------------------+
//| execute_all_tasks                                                |
//+------------------------------------------------------------------+
class CMcpFuncAiTaskRunnerExecuteAllTasks : public CMcpFunction
 {
private:
  const long         m_chart_id_panel;
  const long         m_current_chart_id;

public:
                     CMcpFuncAiTaskRunnerExecuteAllTasks(const long chart_id_panel, const long curr_chart_id)
    :                CMcpFunction(0, false, "aidatataskrunner_execute_all_tasks"),
                     m_chart_id_panel(chart_id_panel), m_current_chart_id(curr_chart_id) {}
                    ~CMcpFuncAiTaskRunnerExecuteAllTasks(void) {}

  //---
  void               Run(CJsonNode& param, CJsonBuilderStr* &out) override final
   {
    out = m_shared_builder;
    ::EventChartCustom(m_chart_id_panel, AIDATATASKRUNER_API_ON_PARAM_CHANGE,
                       m_current_chart_id, double(AIDATATASKRUNER_API_EXECUTE_ALL_TASK_OF_TABLE),
                       AiDataTaskRunnerEmpaquetar("mcp_exec_all", ""));

    //---
    m_shared_builder.PutChar('"');
    m_shared_builder.Obj();
    m_shared_builder.KeyWV("ok").Val(true);
    m_shared_builder.KeyWV("result").ValSWV("queued");
    m_shared_builder.EndObj();
    m_shared_builder.PutChar('"');
   }
 };
}
//+------------------------------------------------------------------+
#endif // AIDATATASKRUNNER_BACKEND_MCP_FUNCTIONS_MQH