mirror of
https://github.com/vdemydiuk/mtapi.git
synced 2026-07-27 18:47:55 +00:00
DW
5983 lines
318 KiB
Plaintext
Executable File
5983 lines
318 KiB
Plaintext
Executable File
#property copyright "Vyacheslav Demidyuk"
|
|
#property link "http://mtapi4.net/"
|
|
#property version "1.8"
|
|
#property description "MtApi connection expert"
|
|
|
|
#include <WinUser32.mqh>
|
|
#include <stdlib.mqh>
|
|
#include <json.mqh>
|
|
|
|
#import "MTConnector.dll"
|
|
bool initExpert(int expertHandle, int port, string symbol, double bid, double ask, string& err);
|
|
bool deinitExpert(int expertHandle, string& err);
|
|
bool updateQuote(int expertHandle, string symbol, double bid, double ask, string& err);
|
|
bool sendEvent(int expertHandle, int eventType, string payload, string& err);
|
|
|
|
bool sendIntResponse(int expertHandle, int response, string& err);
|
|
bool sendBooleanResponse(int expertHandle, int response, string& err);
|
|
bool sendDoubleResponse(int expertHandle, double response, string& err);
|
|
bool sendStringResponse(int expertHandle, string response, string& err);
|
|
bool sendVoidResponse(int expertHandle, string& err);
|
|
bool sendDoubleArrayResponse(int expertHandle, double& values[], int size, string& err);
|
|
bool sendIntArrayResponse(int expertHandle, int& values[], int size, string& err);
|
|
bool sendLongResponse(int expertHandle, long response, string& err);
|
|
bool sendErrorResponse(int expertHandle, int code, string message, string& err);
|
|
|
|
bool getCommandType(int expertHandle, int& res, string& err);
|
|
|
|
bool getIntValue(int expertHandle, int paramIndex, int& res, string& err);
|
|
bool getDoubleValue(int expertHandle, int paramIndex, double& res, string& err);
|
|
bool getStringValue(int expertHandle, int paramIndex, string& res, string& err);
|
|
bool getBooleanValue(int expertHandle, int paramIndex, bool& res, string& err);
|
|
bool getLongValue(int expertHandle, int paramIndex, long& res, string& err);
|
|
|
|
bool containsNamedValue(int expertHandle, string paramName);
|
|
|
|
bool getNamedIntValue(int expertHandle, string paramName, int& res, string& err);
|
|
bool getNamedDoubleValue(int expertHandle, string paramName, double& res, string& err);
|
|
bool getNamedStringValue(int expertHandle, string paramName, string& res, string& err);
|
|
bool getNamedBooleanValue(int expertHandle, string paramName, bool& res, string& err);
|
|
bool getNamedLongValue(int expertHandle, string paramName, long& res, string& err);
|
|
#import
|
|
|
|
extern int Port = 8222;
|
|
|
|
int ExpertHandle;
|
|
|
|
string _error;
|
|
string _response_error;
|
|
bool isCrashed = FALSE;
|
|
|
|
bool IsRemoteReadyForTesting = false;
|
|
|
|
int _lastBarOpenTime;
|
|
|
|
class MtOrder
|
|
{
|
|
public:
|
|
int getTicket() { return _ticket; }
|
|
string getSymbol() { return _symbol; }
|
|
int getOperation() { return _operation; }
|
|
double getOpenPrice() { return _openPrice; }
|
|
double getClosePrice() { return _closePrice; }
|
|
double getLots() { return _lots; }
|
|
double getProfit() { return _profit; }
|
|
string getComment() { return _comment; }
|
|
double getCommission() { return _commission; }
|
|
int getMagicNumber() { return _magicNumber; }
|
|
datetime getOpenTime() { return _openTime; }
|
|
datetime getCloseTime() { return _closeTime; }
|
|
double getSwap() { return _swap; }
|
|
datetime getExpiration() { return _expiration; }
|
|
double getTakeProfit() { return _takeProfit; }
|
|
double getStopLoss() { return _stopLoss; }
|
|
|
|
static bool isLong(int operation)
|
|
{
|
|
if (operation == OP_BUY || operation == OP_BUYLIMIT || operation == OP_BUYSTOP)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
JSONObject* CreateJson()
|
|
{
|
|
JSONObject *jo = new JSONObject();
|
|
jo.put("Ticket", new JSONNumber(_ticket));
|
|
jo.put("Symbol", new JSONString(_symbol));
|
|
jo.put("Operation", new JSONNumber(_operation));
|
|
jo.put("OpenPrice", new JSONNumber(_openPrice));
|
|
jo.put("ClosePrice", new JSONNumber(_closePrice));
|
|
jo.put("Lots", new JSONNumber(_lots));
|
|
jo.put("Profit", new JSONNumber(_profit));
|
|
jo.put("Comment", new JSONString(_comment));
|
|
jo.put("Commission", new JSONString(_commission));
|
|
jo.put("MagicNumber", new JSONNumber(_magicNumber));
|
|
jo.put("Commission", new JSONString(_commission));
|
|
jo.put("MagicNumber", new JSONNumber(_magicNumber));
|
|
jo.put("MtOpenTime", new JSONNumber(_openTime));
|
|
jo.put("MtCloseTime", new JSONNumber(_closeTime));
|
|
jo.put("Swap", new JSONNumber(_swap));
|
|
jo.put("MtExpiration", new JSONNumber(_expiration));
|
|
jo.put("TakeProfit", new JSONNumber(_takeProfit));
|
|
jo.put("StopLoss", new JSONNumber(_stopLoss));
|
|
return jo;
|
|
}
|
|
|
|
static MtOrder* LoadOrder(int index, int select, int pool)
|
|
{
|
|
MtOrder* order = NULL;
|
|
if (OrderSelect(index, select, pool))
|
|
{
|
|
order = new MtOrder();
|
|
order._ticket = OrderTicket();
|
|
order._symbol = OrderSymbol();
|
|
order._operation = OrderType();
|
|
order._openPrice = OrderOpenPrice();
|
|
order._closePrice = OrderClosePrice();
|
|
order._lots = OrderLots();
|
|
order._profit = OrderProfit();
|
|
order._comment = OrderComment();
|
|
order._commission = OrderCommission();
|
|
order._magicNumber = OrderMagicNumber();
|
|
order._openTime = OrderOpenTime();
|
|
order._closeTime = OrderCloseTime();
|
|
order._swap = OrderSwap();
|
|
order._expiration = OrderExpiration();
|
|
order._takeProfit = OrderTakeProfit();
|
|
order._stopLoss = OrderStopLoss();
|
|
}
|
|
return order;
|
|
}
|
|
|
|
private:
|
|
int _ticket;
|
|
string _symbol;
|
|
int _operation;
|
|
double _openPrice;
|
|
double _closePrice;
|
|
double _lots;
|
|
double _profit;
|
|
string _comment;
|
|
double _commission;
|
|
int _magicNumber;
|
|
datetime _openTime;
|
|
datetime _closeTime;
|
|
double _swap;
|
|
datetime _expiration;
|
|
double _takeProfit;
|
|
double _stopLoss;
|
|
};
|
|
|
|
class MtTimeBar
|
|
{
|
|
public:
|
|
MtTimeBar(string symbol, datetime openTime, datetime closeTime, double open, double close, double high, double low)
|
|
{
|
|
_symbol = symbol;
|
|
_openTime = openTime;
|
|
_closeTime = closeTime;
|
|
_open = open;
|
|
_close = close;
|
|
_high = high;
|
|
_low = low;
|
|
}
|
|
|
|
string getSymbol() { return _symbol; }
|
|
datetime getOpenTime() { return _openTime; }
|
|
datetime getCloseTime() { return _closeTime; }
|
|
double getOpen() { return _open; }
|
|
double getClose() { return _close; }
|
|
double getHigh() { return _high; }
|
|
double getLow() { return _low; }
|
|
|
|
JSONObject* CreateJson()
|
|
{
|
|
JSONObject *jo = new JSONObject();
|
|
jo.put("Symbol", new JSONString(_symbol));
|
|
jo.put("MtOpenTime", new JSONNumber(_openTime));
|
|
jo.put("MtCloseTime", new JSONNumber(_closeTime));
|
|
jo.put("Open", new JSONNumber(_open));
|
|
jo.put("Close", new JSONNumber(_close));
|
|
jo.put("High", new JSONNumber(_high));
|
|
jo.put("Low", new JSONNumber(_low));
|
|
return jo;
|
|
}
|
|
|
|
private:
|
|
string _symbol;
|
|
datetime _openTime;
|
|
datetime _closeTime;
|
|
double _open;
|
|
double _close;
|
|
double _high;
|
|
double _low;
|
|
};
|
|
|
|
class MtSession
|
|
{
|
|
public:
|
|
static MtSession* LoadSession(string symbol, int day, int index, int type)
|
|
{
|
|
MtSession *session = new MtSession(symbol, day, index, type);
|
|
|
|
if (type == QUOTE)
|
|
{
|
|
session._hasData = SymbolInfoSessionQuote(symbol, day, index, session._from, session._to);
|
|
}
|
|
else
|
|
{
|
|
session._hasData = SymbolInfoSessionTrade(symbol, day, index, session._from, session._to);
|
|
}
|
|
|
|
return session;
|
|
}
|
|
|
|
JSONObject* CreateJson()
|
|
{
|
|
JSONObject *jo = new JSONObject();
|
|
jo.put("Symbol", new JSONString(_symbol));
|
|
jo.put("DayOfWeek", new JSONNumber(_dayOfWeek));
|
|
jo.put("Index", new JSONNumber(_index));
|
|
jo.put("MtFromTime", new JSONNumber(_from));
|
|
jo.put("MtToTime", new JSONNumber(_to));
|
|
jo.put("HasData", new JSONBool(_hasData));
|
|
jo.put("Type", new JSONNumber(_type));
|
|
return jo;
|
|
}
|
|
|
|
private:
|
|
string _symbol;
|
|
int _dayOfWeek;
|
|
int _index;
|
|
datetime _from;
|
|
datetime _to;
|
|
bool _hasData;
|
|
int _type;
|
|
|
|
MtSession(string symbol, int day, int index, int type)
|
|
{
|
|
_symbol = symbol;
|
|
_dayOfWeek = day;
|
|
_index = index;
|
|
_type = type;
|
|
}
|
|
};
|
|
|
|
enum MtSessionType
|
|
{
|
|
QUOTE,
|
|
TRADE
|
|
};
|
|
|
|
enum MtEventTypes
|
|
{
|
|
LAST_TIME_BAR_EVENT = 1
|
|
};
|
|
|
|
int preinit()
|
|
{
|
|
// StringInit(message,1000,0);
|
|
StringInit(_error,1000,0);
|
|
StringInit(_response_error,1000,0);
|
|
/*
|
|
StringInit(symbolValue,200,0);
|
|
StringInit(commentValue,200,0);
|
|
StringInit(msgValue,200,0);
|
|
StringInit(captionValue,200,0);
|
|
StringInit(filenameValue,200,0);
|
|
StringInit(ftp_pathValue,200,0);
|
|
StringInit(subjectValue,200,0);
|
|
StringInit(some_textValue,200,0);
|
|
StringInit(nameValue,200,0);
|
|
StringInit(prefix_nameValue,200,0);
|
|
StringInit(requestValue, 500,0);
|
|
*/
|
|
return (0);
|
|
}
|
|
|
|
int init() {
|
|
preinit();
|
|
|
|
if (IsDllsAllowed() == FALSE)
|
|
{
|
|
MessageBox("Dlls not allowed.", "MtApi", MB_OK);
|
|
isCrashed = TRUE;
|
|
return (1);
|
|
}
|
|
if (IsLibrariesAllowed() == FALSE)
|
|
{
|
|
MessageBox("Libraries not allowed.", "MtApi", MB_OK);
|
|
isCrashed = TRUE;
|
|
return (1);
|
|
}
|
|
|
|
if (IsTradeAllowed() == FALSE)
|
|
{
|
|
MessageBox("Trade not allowed.", "MtApi", MB_OK);
|
|
isCrashed = TRUE;
|
|
return (1);
|
|
}
|
|
|
|
ExpertHandle = WindowHandle(Symbol(), Period());
|
|
|
|
if (!initExpert(ExpertHandle, Port, Symbol(), Bid, Ask, _error))
|
|
{
|
|
MessageBox(_error, "MtApi", MB_OK);
|
|
isCrashed = TRUE;
|
|
return(1);
|
|
}
|
|
|
|
if (ExecuteCommand() == 1)
|
|
{
|
|
isCrashed = TRUE;
|
|
return (1);
|
|
}
|
|
|
|
//--- Backtesting mode
|
|
if (IsTesting())
|
|
{
|
|
Print("Waiting on remote client...");
|
|
//wait for command (BacktestingReady) from remote side to be ready for work
|
|
while(!IsRemoteReadyForTesting)
|
|
{
|
|
ExecuteCommand();
|
|
|
|
//This section uses a while loop to simulate Sleep() during Backtest.
|
|
unsigned int viSleepUntilTick = GetTickCount() + 100; //100 milliseconds
|
|
while(GetTickCount() < viSleepUntilTick)
|
|
{
|
|
//Do absolutely nothing. Just loop until the desired tick is reached.
|
|
}
|
|
}
|
|
}
|
|
//---
|
|
|
|
_lastBarOpenTime = Time[0];
|
|
|
|
return (0);
|
|
}
|
|
|
|
int deinit() {
|
|
if (isCrashed == 0)
|
|
{
|
|
if (!deinitExpert(ExpertHandle, _error))
|
|
{
|
|
MessageBox(_error, "MtApi", MB_OK);
|
|
isCrashed = TRUE;
|
|
return (1);
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int start()
|
|
{
|
|
updateQuote(ExpertHandle, Symbol(), Bid, Ask, _error);
|
|
|
|
if (_lastBarOpenTime != Time[0])
|
|
{
|
|
Print("start() new bar: _lastBarOpenTime = ", _lastBarOpenTime, "; Time[0] = ", Time[0]);
|
|
|
|
double open = Open[1];
|
|
double close = Close[1];
|
|
double high = High[1];
|
|
double low = Low[1];
|
|
|
|
MtTimeBar* timeBar = new MtTimeBar(Symbol(), _lastBarOpenTime, Time[0], open, close, high, low);
|
|
SendLastTimeBartEvent(timeBar);
|
|
delete timeBar;
|
|
|
|
_lastBarOpenTime = Time[0];
|
|
}
|
|
|
|
|
|
if (IsTesting())
|
|
{
|
|
while(true)
|
|
{
|
|
int executedCommand = ExecuteCommand();
|
|
if (executedCommand == 0) break;
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
void OnTimer()
|
|
{
|
|
while(true)
|
|
{
|
|
int executedCommand = ExecuteCommand();
|
|
if (executedCommand == 0) return;
|
|
}
|
|
}
|
|
|
|
void SendLastTimeBartEvent(MtTimeBar* timeBar)
|
|
{
|
|
JSONObject* json = timeBar.CreateJson();
|
|
if (sendEvent(ExpertHandle, (int)LAST_TIME_BAR_EVENT, json.toString(), _error))
|
|
{
|
|
Print("Send LastTimeBar event: payload = ", json.toString());
|
|
}
|
|
else
|
|
{
|
|
PrintFormat("[ERROR] SendLastTimeBartEvent: %s", _error);
|
|
}
|
|
|
|
delete json;
|
|
}
|
|
|
|
int ExecuteCommand()
|
|
{
|
|
int command_type = 0;
|
|
|
|
if (!getCommandType(ExpertHandle, command_type, _error))
|
|
{
|
|
Print("[ERROR] ExecuteCommand: Failed to get command type!", _error);
|
|
return (0);
|
|
}
|
|
|
|
if (command_type > 0)
|
|
{
|
|
Print("ExecuteCommand: commnad type = ", command_type);
|
|
}
|
|
|
|
switch (command_type)
|
|
{
|
|
case 0:
|
|
//NoCommand
|
|
break;
|
|
case 155: //Request
|
|
Execute_Request();
|
|
break;
|
|
case 151: //OrderCloseAll
|
|
Execute_OrderCloseAll();
|
|
break;
|
|
case 3: // OrderCloseBy
|
|
Execute_OrderCloseBy();
|
|
break;
|
|
case 4: // OrderClosePrice
|
|
Execute_OrderClosePrice();
|
|
break;
|
|
case 1004: // OrderClosePriceByTicket
|
|
Execute_OrderClosePriceByTicket();
|
|
break;
|
|
case 5: //OrderCloseTime
|
|
Execute_OrderCloseTime();
|
|
break;
|
|
case 6: //OrderComment
|
|
Execute_OrderComment();
|
|
break;
|
|
case 7: //OrderCommission
|
|
Execute_OrderCommission();
|
|
break;
|
|
case 8: //OrderDelete
|
|
Execute_OrderDelete();
|
|
break;
|
|
case 9: //OrderExpiration
|
|
Execute_OrderExpiration();
|
|
break;
|
|
case 10: //OrderLots
|
|
Execute_OrderLots();
|
|
break;
|
|
case 11: //OrderMagicNumber
|
|
Execute_OrderMagicNumber();
|
|
break;
|
|
case 12: //OrderModify
|
|
Execute_OrderModify();
|
|
break;
|
|
case 13: //OrderOpenPrice
|
|
Execute_OrderOpenPrice();
|
|
break;
|
|
case 1013: // OrderOpenPriceByTicket
|
|
Execute_OrderOpenPriceByTicket();
|
|
break;
|
|
case 14: //OrderOpenTime
|
|
Execute_OrderOpenTime();
|
|
break;
|
|
case 15: //OrderPrint
|
|
Execute_OrderPrint();
|
|
break;
|
|
case 16: //OrderProfit
|
|
Execute_OrderProfit();
|
|
break;
|
|
case 17: //OrderSelect
|
|
Execute_OrderSelect();
|
|
break;
|
|
case 18: //OrdersHistoryTotal
|
|
Execute_OrdersHistoryTotal();
|
|
break;
|
|
case 19: //OrderStopLoss
|
|
Execute_OrderStopLoss();
|
|
break;
|
|
case 20: //OrdersTotal
|
|
Execute_OrdersTotal();
|
|
break;
|
|
case 21: //OrderSwap
|
|
Execute_OrderSwap();
|
|
break;
|
|
case 22: //OrderSymbol
|
|
Execute_OrderSymbol();
|
|
break;
|
|
case 23: //OrderTakeProfit
|
|
Execute_OrderTakeProfit();
|
|
break;
|
|
case 24: //OrderTicket
|
|
Execute_OrderTicket();
|
|
break;
|
|
case 25: //OrderType
|
|
Execute_OrderType();
|
|
break;
|
|
case 26: //GetLastError
|
|
Execute_GetLastError();
|
|
break;
|
|
case 27: //IsConnected
|
|
Execute_IsConnected();
|
|
break;
|
|
case 28: //IsDemo
|
|
Execute_IsDemo();
|
|
break;
|
|
case 29: //IsDllsAllowed
|
|
Execute_IsDllsAllowed();
|
|
break;
|
|
case 30: //IsExpertEnabled
|
|
Execute_IsExpertEnabled();
|
|
break;
|
|
case 31: //IsLibrariesAllowed
|
|
Execute_IsLibrariesAllowed();
|
|
break;
|
|
case 32: //IsOptimization
|
|
Execute_IsOptimization();
|
|
break;
|
|
case 33: //IsStopped
|
|
Execute_IsStopped();
|
|
break;
|
|
case 34: //IsTesting
|
|
Execute_IsTesting();
|
|
break;
|
|
case 35: //IsTradeAllowed
|
|
Execute_IsTradeAllowed();
|
|
break;
|
|
case 36: //IsTradeContextBusy
|
|
Execute_IsTradeContextBusy();
|
|
break;
|
|
case 37: //IsVisualMode
|
|
Execute_IsVisualMode();
|
|
break;
|
|
case 38: //UninitializeReason
|
|
Execute_UninitializeReason();
|
|
break;
|
|
case 39: //ErrorDescription
|
|
Execute_ErrorDescription();
|
|
break;
|
|
case 40: //AccountBalance
|
|
Execute_AccountBalance();
|
|
break;
|
|
case 41: //AccountCredit
|
|
Execute_AccountCredit();
|
|
break;
|
|
case 42: //AccountCompany
|
|
Execute_AccountCompany();
|
|
break;
|
|
case 43: //AccountCurrency
|
|
Execute_AccountCurrency();
|
|
break;
|
|
case 44: //AccountEquity
|
|
Execute_AccountEquity();
|
|
break;
|
|
case 45: //AccountFreeMargin
|
|
Execute_AccountFreeMargin();
|
|
break;
|
|
case 46: //AccountFreeMarginCheck
|
|
Execute_AccountFreeMarginCheck();
|
|
break;
|
|
case 47: //AccountFreeMarginMode
|
|
Execute_AccountFreeMarginMode();
|
|
break;
|
|
case 48: //AccountLeverage
|
|
Execute_AccountLeverage();
|
|
break;
|
|
case 49: //AccountMargin
|
|
Execute_AccountMargin();
|
|
break;
|
|
case 50: //AccountName
|
|
Execute_AccountName();
|
|
break;
|
|
case 51: //AccountNumber
|
|
Execute_AccountNumber();
|
|
break;
|
|
case 52: //AccountProfit
|
|
Execute_AccountProfit();
|
|
break;
|
|
case 53: //AccountServer
|
|
Execute_AccountServer();
|
|
break;
|
|
case 54: //AccountStopoutLevel
|
|
Execute_AccountStopoutLevel();
|
|
break;
|
|
case 55: //AccountStopoutMode
|
|
Execute_AccountStopoutMode();
|
|
break;
|
|
case 56: //Alert
|
|
Execute_Alert();
|
|
break;
|
|
case 57: //Comment
|
|
Execute_Comment();
|
|
break;
|
|
case 58: //GetTickCount
|
|
Execute_GetTickCount();
|
|
break;
|
|
case 59: //MarketInfo
|
|
Execute_MarketInfo();
|
|
break;
|
|
case 60: //MessageBox
|
|
Execute_MessageBox(false);
|
|
break;
|
|
case 61: //MessageBoxA
|
|
Execute_MessageBox(true);
|
|
break;
|
|
case 62: //PlaySound
|
|
Execute_PlaySound();
|
|
break;
|
|
case 63: //Print
|
|
Execute_Print();
|
|
break;
|
|
case 64: //SendFTP
|
|
Execute_SendFTP(false);
|
|
break;
|
|
case 65: //SendFTPA
|
|
Execute_SendFTP(true);
|
|
break;
|
|
case 66: //SendMail
|
|
Execute_SendMail();
|
|
break;
|
|
case 67: //Sleep
|
|
Execute_Sleep();
|
|
break;
|
|
case 68: //TerminalCompany
|
|
Execute_TerminalCompany();
|
|
break;
|
|
case 69: //TerminalName
|
|
Execute_TerminalName();
|
|
break;
|
|
case 70: //TerminalPath
|
|
Execute_TerminalPath();
|
|
break;
|
|
case 71: //Day
|
|
Execute_Day();
|
|
break;
|
|
case 72: //DayOfWeek
|
|
Execute_DayOfWeek();
|
|
break;
|
|
case 73: //DayOfYear
|
|
Execute_DayOfYear();
|
|
break;
|
|
case 74: //Hour
|
|
Execute_Hour();
|
|
break;
|
|
case 75: //Minute
|
|
Execute_Minute();
|
|
break;
|
|
case 76: //Month
|
|
Execute_Month();
|
|
break;
|
|
case 77: //Seconds
|
|
Execute_Seconds();
|
|
break;
|
|
case 78: //TimeCurrent
|
|
Execute_TimeCurrent();
|
|
break;
|
|
case 79: //TimeDay
|
|
Execute_TimeDay();
|
|
break;
|
|
case 80: //TimeDayOfWeek
|
|
Execute_TimeDayOfWeek();
|
|
break;
|
|
case 81: //TimeDayOfYear
|
|
Execute_TimeDayOfYear();
|
|
break;
|
|
case 82: //TimeHour
|
|
Execute_TimeHour();
|
|
break;
|
|
case 83: //TimeLocal
|
|
Execute_TimeLocal();
|
|
break;
|
|
case 84: //TimeMinute
|
|
Execute_TimeMinute();
|
|
break;
|
|
case 85: //TimeMonth
|
|
Execute_TimeMonth();
|
|
break;
|
|
case 86: //TimeSeconds
|
|
Execute_TimeSeconds();
|
|
break;
|
|
case 87: //TimeYear
|
|
Execute_TimeYear();
|
|
break;
|
|
case 88: //Year
|
|
Execute_Year();
|
|
break;
|
|
case 89: //GlobalVariableCheck
|
|
Execute_GlobalVariableCheck();
|
|
break;
|
|
case 90: //GlobalVariableDel
|
|
Execute_GlobalVariableDel();
|
|
break;
|
|
case 91: //GlobalVariableGet
|
|
Execute_GlobalVariableGet();
|
|
break;
|
|
case 92: //GlobalVariableName
|
|
Execute_GlobalVariableName();
|
|
break;
|
|
case 93: //GlobalVariableSet
|
|
Execute_GlobalVariableSet();
|
|
break;
|
|
case 94: //GlobalVariableSetOnCondition
|
|
Execute_GlobalVariableSetOnCondition();
|
|
break;
|
|
case 95: //GlobalVariablesDeleteAll
|
|
Execute_GlobalVariablesDeleteAll();
|
|
break;
|
|
case 96: //GlobalVariablesTotal
|
|
Execute_GlobalVariablesTotal();
|
|
break;
|
|
case 97: //iAC
|
|
Execute_iAC();
|
|
break;
|
|
case 98: //iAD
|
|
Execute_iAD();
|
|
break;
|
|
case 99: //iAlligator
|
|
Execute_iAlligator();
|
|
break;
|
|
case 100: //iADX
|
|
Execute_iADX();
|
|
break;
|
|
case 101: //iATR
|
|
Execute_iATR();
|
|
break;
|
|
case 102: //iAO
|
|
Execute_iAO();
|
|
break;
|
|
case 103: //iBearsPower
|
|
Execute_iBearsPower();
|
|
break;
|
|
case 104: //iBands
|
|
Execute_iBands();
|
|
break;
|
|
case 105: //iBandsOnArray
|
|
Execute_iBandsOnArray();
|
|
break;
|
|
case 106: //iBullsPower
|
|
Execute_iBullsPower();
|
|
break;
|
|
case 107: //iCCI
|
|
Execute_iCCI();
|
|
break;
|
|
case 108: //iCCIOnArray
|
|
Execute_iCCIOnArray();
|
|
break;
|
|
case 109: //iCustom
|
|
//redesigned to request
|
|
break;
|
|
case 110: //iDeMarker
|
|
Execute_iDeMarker();
|
|
break;
|
|
case 111: //iEnvelopes
|
|
Execute_iEnvelopes();
|
|
break;
|
|
case 112: //iEnvelopesOnArray
|
|
Execute_iEnvelopesOnArray();
|
|
break;
|
|
case 113: //iForce
|
|
Execute_iForce();
|
|
break;
|
|
case 114: //iFractals
|
|
Execute_iFractals();
|
|
break;
|
|
case 115: //iGator
|
|
Execute_iGator();
|
|
break;
|
|
case 116: //iIchimoku
|
|
Execute_iIchimoku();
|
|
break;
|
|
case 117: //iBWMFI
|
|
Execute_iBWMFI();
|
|
break;
|
|
case 118: //iMomentum
|
|
Execute_iMomentum();
|
|
break;
|
|
case 119: //iMomentumOnArray
|
|
Execute_iMomentumOnArray();
|
|
break;
|
|
case 120: //iMFI
|
|
Execute_iMFI();
|
|
break;
|
|
case 121: //iMA
|
|
Execute_iMA();
|
|
break;
|
|
case 122: //iMAOnArray
|
|
Execute_iMAOnArray();
|
|
break;
|
|
case 123: //iOsMA
|
|
Execute_iOsMA();
|
|
break;
|
|
case 124: //iMACD
|
|
Execute_iMACD();
|
|
break;
|
|
case 125: //iOBV
|
|
Execute_iOBV();
|
|
break;
|
|
case 126: //iSAR
|
|
Execute_iSAR();
|
|
break;
|
|
case 127: //iRSI
|
|
Execute_iRSI();
|
|
break;
|
|
case 128: //iRSIOnArray
|
|
Execute_iRSIOnArray();
|
|
break;
|
|
case 129: //iRVI
|
|
Execute_iRVI();
|
|
break;
|
|
case 130: //iStdDev
|
|
Execute_iStdDev();
|
|
break;
|
|
case 131: //iStdDevOnArray
|
|
Execute_iStdDevOnArray();
|
|
break;
|
|
case 132: //iStochastic
|
|
Execute_iStochastic();
|
|
break;
|
|
case 133: //iWPR
|
|
Execute_iWPR();
|
|
break;
|
|
case 134: //iBars
|
|
Execute_iBars();
|
|
break;
|
|
case 135: //iBarShift
|
|
Execute_iBarShift();
|
|
break;
|
|
case 136: //iClose
|
|
Execute_iClose();
|
|
break;
|
|
case 137: //iHigh
|
|
Execute_iHigh();
|
|
break;
|
|
case 138: //iHighest
|
|
Execute_iHighest();
|
|
break;
|
|
case 139: //iLow
|
|
Execute_iLow();
|
|
break;
|
|
case 140: //iLowest
|
|
Execute_iLowest();
|
|
break;
|
|
case 141: //iOpen
|
|
Execute_iOpen();
|
|
break;
|
|
case 142: //iTime
|
|
Execute_iTime();
|
|
break;
|
|
case 143: //iVolume
|
|
Execute_iVolume();
|
|
break;
|
|
case 144: //iCloseArray
|
|
Execute_iCloseArray();
|
|
break;
|
|
case 145: //iHighArray
|
|
Execute_iHighArray();
|
|
break;
|
|
case 146: //iLowArray
|
|
Execute_iLowArray();
|
|
break;
|
|
case 147: //iOpenArray
|
|
Execute_iOpenArray();
|
|
break;
|
|
case 148: //iVolumeArray
|
|
Execute_iVolumeArray();
|
|
break;
|
|
case 149: //iTimeArray
|
|
Execute_iTimeArray();
|
|
break;
|
|
case 150: //RefreshRates
|
|
Execute_RefreshRates();
|
|
break;
|
|
case 153: //TerminalInfoString
|
|
Execute_TerminalInfoString();
|
|
break;
|
|
case 154: //SymbolInfoString
|
|
Execute_SymbolInfoString();
|
|
break;
|
|
case 156: //BacktestingReady
|
|
Execute_BacktestingReady();
|
|
break;
|
|
case 200: //SymbolsTotal
|
|
Execute_SymbolsTotal();
|
|
break;
|
|
case 201: //SymbolName
|
|
Execute_SymbolName();
|
|
break;
|
|
case 202: //SymbolSelect
|
|
Execute_SymbolSelect();
|
|
break;
|
|
case 203: //SymbolInfoInteger
|
|
Execute_SymbolInfoInteger();
|
|
break;
|
|
case 204: //TerminalInfoInteger
|
|
Execute_TerminalInfoInteger();
|
|
break;
|
|
case 205: //TerminalInfoDouble
|
|
Execute_TerminalInfoDouble();
|
|
break;
|
|
case 206: //ChartId
|
|
Execute_CharId();
|
|
break;
|
|
case 207: //ChartRedraw
|
|
Execute_ChartRedraw();
|
|
break;
|
|
case 208: //ObjectCreate
|
|
Execute_ObjectCreate();
|
|
break;
|
|
|
|
default:
|
|
_error = "Unknown command type = " + command_type;
|
|
Print("[ERROR] ExecuteCommand: ", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
break;
|
|
}
|
|
|
|
return (command_type);
|
|
}
|
|
|
|
void Execute_Request()
|
|
{
|
|
string request;
|
|
StringInit(request, 1000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, request, _error))
|
|
{
|
|
PrintParamError("Request", "request", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
Print("Execute_Request: ", request);
|
|
|
|
string response = OnRequest(request);
|
|
|
|
if (!sendStringResponse(ExpertHandle, response, _response_error))
|
|
{
|
|
PrintResponseError("Request", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderCloseAll()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, OrderCloseAll(), _response_error))
|
|
{
|
|
PrintResponseError("OrderCloseAll", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderCloseBy()
|
|
{
|
|
int ticket;
|
|
int opposite;
|
|
int color_value;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, ticket, _error))
|
|
{
|
|
PrintParamError("OrderCloseBy", "ticket", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, opposite, _error))
|
|
{
|
|
PrintParamError("OrderCloseBy", "opposite", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, color_value, _error))
|
|
{
|
|
PrintParamError("OrderCloseBy", "color", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool res = OrderCloseBy(ticket, opposite, color_value);
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("OrderCloseBy", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderClosePrice()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderClosePrice(), _response_error))
|
|
{
|
|
PrintResponseError("OrderClosePrice", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderClosePriceByTicket()
|
|
{
|
|
int ticket;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, ticket, _error))
|
|
{
|
|
PrintParamError("OrderClosePriceByTicket", "ticket", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool selected = OrderSelect(ticket, SELECT_BY_TICKET);
|
|
if (!selected)
|
|
{
|
|
int last_error = GetLastError();
|
|
PrintFormat("[ERROR] Command: %s, Failed to select order! ErrorCode = %d", "OrderClosePriceByTicket", last_error);
|
|
sendErrorResponse(ExpertHandle, last_error, "Failed to select order", _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, OrderClosePrice(), _response_error))
|
|
{
|
|
PrintResponseError("OrderClosePriceByTicket", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderCloseTime()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderCloseTime(), _response_error))
|
|
{
|
|
PrintResponseError("OrderCloseTime", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderComment()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, OrderComment(), _response_error))
|
|
{
|
|
PrintResponseError("OrderComment", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderCommission()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderCommission(), _response_error))
|
|
{
|
|
PrintResponseError("OrderCommission", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderDelete()
|
|
{
|
|
int ticket;
|
|
int arrow_color;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, ticket, _error))
|
|
{
|
|
PrintParamError("OrderDelete", "ticket", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, arrow_color, _error))
|
|
{
|
|
PrintParamError("OrderDelete", "arrow_color", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, OrderDelete(ticket, arrow_color), _response_error))
|
|
{
|
|
PrintResponseError("OrderDelete", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderExpiration()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderExpiration(), _response_error))
|
|
{
|
|
PrintResponseError("OrderExpiration", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderLots()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderLots(), _response_error))
|
|
{
|
|
PrintResponseError("OrderLots", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderMagicNumber()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderMagicNumber(), _response_error))
|
|
{
|
|
PrintResponseError("OrderMagicNumber", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderModify()
|
|
{
|
|
int ticket;
|
|
double price;
|
|
double stoploss;
|
|
double takeprofit;
|
|
int expiration;
|
|
int arrow_color;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, ticket, _error))
|
|
{
|
|
PrintParamError("OrderModify", "ticket", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 1, price, _error))
|
|
{
|
|
PrintParamError("OrderModify", "price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 2, stoploss, _error))
|
|
{
|
|
PrintParamError("OrderModify", "stoploss", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 3, takeprofit, _error))
|
|
{
|
|
PrintParamError("OrderModify", "takeprofit", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, expiration, _error))
|
|
{
|
|
PrintParamError("OrderModify", "expiration", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, arrow_color, _error))
|
|
{
|
|
PrintParamError("OrderModify", "arrow_color", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool res = OrderModify(ticket, price, stoploss, takeprofit, expiration, arrow_color);
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("OrderModify", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderOpenPrice()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderOpenPrice(), _response_error))
|
|
{
|
|
PrintResponseError("OrderOpenPrice", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderOpenPriceByTicket()
|
|
{
|
|
int ticket;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, ticket, _error))
|
|
{
|
|
PrintParamError("OrderOpenPriceByTicket", "ticket", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool selected = OrderSelect(ticket, SELECT_BY_TICKET);
|
|
if (!selected)
|
|
{
|
|
int last_error = GetLastError();
|
|
PrintFormat("[ERROR] Command: %s, Failed to select order! ErrorCode = %d", "OrderOpenPriceByTicket", last_error);
|
|
sendErrorResponse(ExpertHandle, last_error, "Failed to select order", _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, OrderOpenPrice(), _response_error))
|
|
{
|
|
PrintResponseError("OrderOpenPriceByTicket", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderOpenTime()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderOpenTime(), _response_error))
|
|
{
|
|
PrintResponseError("OrderOpenTime", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderPrint()
|
|
{
|
|
OrderPrint();
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("OrderPrint", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderProfit()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderProfit(), _response_error))
|
|
{
|
|
PrintResponseError("OrderProfit", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderSelect()
|
|
{
|
|
int index;
|
|
int select;
|
|
int pool;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, index, _error))
|
|
{
|
|
PrintParamError("OrderSelect", "index", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, select, _error))
|
|
{
|
|
PrintParamError("OrderSelect", "select", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, pool, _error))
|
|
{
|
|
PrintParamError("OrderSelect", "pool", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, OrderSelect(index, select, pool), _response_error))
|
|
{
|
|
PrintResponseError("OrderSelect", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrdersHistoryTotal()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrdersHistoryTotal(), _response_error))
|
|
{
|
|
PrintResponseError("OrdersHistoryTotal", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderStopLoss()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderStopLoss(), _response_error))
|
|
{
|
|
PrintResponseError("OrderStopLoss", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrdersTotal()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrdersTotal(), _response_error))
|
|
{
|
|
PrintResponseError("OrdersTotal", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderSwap()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderSwap(), _response_error))
|
|
{
|
|
PrintResponseError("OrderSwap", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderSymbol()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, OrderSymbol(), _response_error))
|
|
{
|
|
PrintResponseError("OrderSymbol", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderTakeProfit()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, OrderTakeProfit(), _response_error))
|
|
{
|
|
PrintResponseError("OrderTakeProfit", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderTicket()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderTicket(), _response_error))
|
|
{
|
|
PrintResponseError("OrderTicket", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_OrderType()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, OrderType(), _response_error))
|
|
{
|
|
PrintResponseError("OrderType", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GetLastError()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, GetLastError(), _response_error))
|
|
{
|
|
PrintResponseError("GetLastError", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsConnected()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsConnected(), _response_error))
|
|
{
|
|
PrintResponseError("IsConnected", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsDemo()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsDemo(), _response_error))
|
|
{
|
|
PrintResponseError("IsDemo", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsDllsAllowed()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsDllsAllowed(), _response_error))
|
|
{
|
|
PrintResponseError("IsDllsAllowed", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsExpertEnabled()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsExpertEnabled(), _response_error))
|
|
{
|
|
PrintResponseError("IsExpertEnabled", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsLibrariesAllowed()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsLibrariesAllowed(), _response_error))
|
|
{
|
|
PrintResponseError("IsLibrariesAllowed", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsOptimization()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsOptimization(), _response_error))
|
|
{
|
|
PrintResponseError("IsOptimization", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsStopped()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsStopped(), _response_error))
|
|
{
|
|
PrintResponseError("IsStopped", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsTesting()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsTesting(), _response_error))
|
|
{
|
|
PrintResponseError("IsTesting", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsTradeAllowed()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsTradeAllowed(), _response_error))
|
|
{
|
|
PrintResponseError("IsTradeAllowed", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsTradeContextBusy()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsTradeContextBusy(), _response_error))
|
|
{
|
|
PrintResponseError("IsTradeContextBusy", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_IsVisualMode()
|
|
{
|
|
if (!sendBooleanResponse(ExpertHandle, IsVisualMode(), _response_error))
|
|
{
|
|
PrintResponseError("IsVisualMode", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_UninitializeReason()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, UninitializeReason(), _response_error))
|
|
{
|
|
PrintResponseError("UninitializeReason", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_ErrorDescription()
|
|
{
|
|
int error_code;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, error_code, _error))
|
|
{
|
|
PrintParamError("ErrorDescription", "errorCode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendStringResponse(ExpertHandle, ErrorDescription(error_code), _response_error))
|
|
{
|
|
PrintResponseError("ErrorDescription", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountBalance()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountBalance(), _response_error))
|
|
{
|
|
PrintResponseError("AccountBalance", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountCredit()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountCredit(), _response_error))
|
|
{
|
|
PrintResponseError("AccountCredit", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountCompany()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, AccountCompany(), _response_error))
|
|
{
|
|
PrintResponseError("AccountCompany", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountCurrency()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, AccountCurrency(), _response_error))
|
|
{
|
|
PrintResponseError("AccountCurrency", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountEquity()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountEquity(), _response_error))
|
|
{
|
|
PrintResponseError("AccountEquity", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountFreeMargin()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountFreeMargin(), _response_error))
|
|
{
|
|
PrintResponseError("AccountFreeMargin", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountFreeMarginCheck()
|
|
{
|
|
string symbol;
|
|
int cmd;
|
|
double volume;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("AccountFreeMarginCheck", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, cmd, _error))
|
|
{
|
|
PrintParamError("AccountFreeMarginCheck", "cmd", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 2, volume, _error))
|
|
{
|
|
PrintParamError("AccountFreeMarginCheck", "volume", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = AccountFreeMarginCheck(symbol, cmd, volume);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("AccountFreeMarginCheck", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountFreeMarginMode()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountFreeMarginMode(), _response_error))
|
|
{
|
|
PrintResponseError("AccountFreeMarginMode", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountLeverage()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, AccountLeverage(), _response_error))
|
|
{
|
|
PrintResponseError("AccountLeverage", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountMargin()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountMargin(), _response_error))
|
|
{
|
|
PrintResponseError("AccountMargin", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountName()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, AccountName(), _response_error))
|
|
{
|
|
PrintResponseError("AccountName", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountNumber()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, AccountNumber(), _response_error))
|
|
{
|
|
PrintResponseError("AccountNumber", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountProfit()
|
|
{
|
|
if (!sendDoubleResponse(ExpertHandle, AccountProfit(), _response_error))
|
|
{
|
|
PrintResponseError("AccountProfit", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountServer()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, AccountServer(), _response_error))
|
|
{
|
|
PrintResponseError("AccountServer", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountStopoutLevel()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, AccountStopoutLevel(), _response_error))
|
|
{
|
|
PrintResponseError("AccountStopoutLevel", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_AccountStopoutMode()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, AccountStopoutMode(), _response_error))
|
|
{
|
|
PrintResponseError("AccountStopoutMode", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Alert()
|
|
{
|
|
string msg;
|
|
StringInit(msg, 1000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, msg, _error))
|
|
{
|
|
PrintParamError("Alert", "msg", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
Alert(msg);
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("Alert", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Comment()
|
|
{
|
|
string msg;
|
|
StringInit(msg, 1000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, msg, _error))
|
|
{
|
|
PrintParamError("Comment", "msg", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
Comment(msg);
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("Comment", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GetTickCount()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, GetTickCount(), _response_error))
|
|
{
|
|
PrintResponseError("GetTickCount", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_MarketInfo()
|
|
{
|
|
string symbol;
|
|
int type;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("MarketInfo", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, type, _error))
|
|
{
|
|
PrintParamError("MarketInfo", "type", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, MarketInfo(symbol, type), _response_error))
|
|
{
|
|
PrintResponseError("MarketInfo", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_MessageBox(bool use_ext_params)
|
|
{
|
|
string text;
|
|
string caption = NULL;
|
|
int flag = 0;
|
|
StringInit(text, 2000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, text, _error))
|
|
{
|
|
PrintParamError("MessageBox", "text", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (use_ext_params)
|
|
{
|
|
StringInit(caption, 1000, 0);
|
|
if (!getStringValue(ExpertHandle, 1, caption, _error))
|
|
{
|
|
PrintParamError("MessageBox", "caption", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, flag, _error))
|
|
{
|
|
PrintParamError("MessageBox", "flag", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, MessageBox(text, caption, flag), _response_error))
|
|
{
|
|
PrintResponseError("MessageBox", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_PlaySound()
|
|
{
|
|
string filename;
|
|
StringInit(filename, 1000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, filename, _error))
|
|
{
|
|
PrintParamError("PlaySound", "filename", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, PlaySound(filename), _response_error))
|
|
{
|
|
PrintResponseError("PlaySound", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Print()
|
|
{
|
|
string msg;
|
|
StringInit(msg, 1000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, msg, _error))
|
|
{
|
|
PrintParamError("Print", "msg", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
Print(msg);
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("Print", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SendFTP(bool use_path)
|
|
{
|
|
string filename;
|
|
string ftp_path = NULL;
|
|
StringInit(filename, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, filename, _error))
|
|
{
|
|
PrintParamError("SendFTP", "filename", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (use_path)
|
|
{
|
|
StringInit(ftp_path, 500, 0);
|
|
if (!getStringValue(ExpertHandle, 1, ftp_path, _error))
|
|
{
|
|
PrintParamError("SendFTP", "ftp_path", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, SendFTP(filename, ftp_path), _response_error))
|
|
{
|
|
PrintResponseError("SendFTP", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SendMail()
|
|
{
|
|
string subject;
|
|
string some_text;
|
|
StringInit(subject, 1000, 0);
|
|
StringInit(some_text, 10000, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, subject, _error))
|
|
{
|
|
PrintParamError("SendMail", "subject", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getStringValue(ExpertHandle, 1, some_text, _error))
|
|
{
|
|
PrintParamError("SendMail", "some_text", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, SendMail(subject, some_text), _response_error))
|
|
{
|
|
PrintResponseError("SendMail", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Sleep()
|
|
{
|
|
int milliseconds;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, milliseconds, _error))
|
|
{
|
|
PrintParamError("Sleep", "milliseconds", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
Sleep(milliseconds);
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("Sleep", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalCompany()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, TerminalCompany(), _response_error))
|
|
{
|
|
PrintResponseError("TerminalCompany", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalName()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, TerminalName(), _response_error))
|
|
{
|
|
PrintResponseError("TerminalName", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalPath()
|
|
{
|
|
if (!sendStringResponse(ExpertHandle, TerminalPath(), _response_error))
|
|
{
|
|
PrintResponseError("TerminalPath", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Day()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Day(), _response_error))
|
|
{
|
|
PrintResponseError("Day", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_DayOfWeek()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, DayOfWeek(), _response_error))
|
|
{
|
|
PrintResponseError("DayOfWeek", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_DayOfYear()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, DayOfYear(), _response_error))
|
|
{
|
|
PrintResponseError("DayOfYear", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Hour()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Hour(), _response_error))
|
|
{
|
|
PrintResponseError("Hour", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Minute()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Minute(), _response_error))
|
|
{
|
|
PrintResponseError("Minute", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Month()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Month(), _response_error))
|
|
{
|
|
PrintResponseError("Month", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Seconds()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Seconds(), _response_error))
|
|
{
|
|
PrintResponseError("Seconds", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeCurrent()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, TimeCurrent(), _response_error))
|
|
{
|
|
PrintResponseError("TimeCurrent", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeDay()
|
|
{
|
|
int date;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, date, _error))
|
|
{
|
|
PrintParamError("TimeDay", "date", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeDay(date), _response_error))
|
|
{
|
|
PrintResponseError("TimeDay", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeDayOfWeek()
|
|
{
|
|
int date;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, date, _error))
|
|
{
|
|
PrintParamError("TimeDayOfWeek", "date", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeDayOfWeek(date), _response_error))
|
|
{
|
|
PrintResponseError("TimeDayOfWeek", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeDayOfYear()
|
|
{
|
|
int date;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, date, _error))
|
|
{
|
|
PrintParamError("TimeDayOfYear", "date", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeDayOfYear(date), _response_error))
|
|
{
|
|
PrintResponseError("TimeDayOfYear", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeHour()
|
|
{
|
|
int time;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, time, _error))
|
|
{
|
|
PrintParamError("TimeHour", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeHour(time), _response_error))
|
|
{
|
|
PrintResponseError("TimeHour", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeLocal()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, TimeLocal(), _response_error))
|
|
{
|
|
PrintResponseError("TimeLocal", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeMinute()
|
|
{
|
|
int time;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, time, _error))
|
|
{
|
|
PrintParamError("TimeMinute", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeMinute(time), _response_error))
|
|
{
|
|
PrintResponseError("TimeMinute", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeMonth()
|
|
{
|
|
int time;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, time, _error))
|
|
{
|
|
PrintParamError("TimeMonth", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeMonth(time), _response_error))
|
|
{
|
|
PrintResponseError("TimeMonth", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeSeconds()
|
|
{
|
|
int time;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, time, _error))
|
|
{
|
|
PrintParamError("TimeSeconds", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeSeconds(time), _response_error))
|
|
{
|
|
PrintResponseError("TimeSeconds", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TimeYear()
|
|
{
|
|
int time;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, time, _error))
|
|
{
|
|
PrintParamError("TimeYear", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, TimeYear(time), _response_error))
|
|
{
|
|
PrintResponseError("TimeYear", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_Year()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, Year(), _response_error))
|
|
{
|
|
PrintResponseError("Year", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableCheck()
|
|
{
|
|
string name;
|
|
StringInit(name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, name, _error))
|
|
{
|
|
PrintParamError("GlobalVariableCheck", "name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, GlobalVariableCheck(name), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableCheck", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableDel()
|
|
{
|
|
string name;
|
|
StringInit(name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, name, _error))
|
|
{
|
|
PrintParamError("GlobalVariableDel", "name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, GlobalVariableDel(name), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableDel", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableGet()
|
|
{
|
|
string name;
|
|
StringInit(name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, name, _error))
|
|
{
|
|
PrintParamError("GlobalVariableGet", "name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, GlobalVariableGet(name), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableGet", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableName()
|
|
{
|
|
int index;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, index, _error))
|
|
{
|
|
PrintParamError("GlobalVariableName", "index", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendStringResponse(ExpertHandle, GlobalVariableName(index), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableName", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableSet()
|
|
{
|
|
string name;
|
|
double value;
|
|
StringInit(name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, name, _error))
|
|
{
|
|
PrintParamError("GlobalVariableSet", "name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 1, value, _error))
|
|
{
|
|
PrintParamError("GlobalVariableSet", "value", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = GlobalVariableSet(name, value);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableSet", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariableSetOnCondition()
|
|
{
|
|
string name;
|
|
double value;
|
|
double check_value;
|
|
StringInit(name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, name, _error))
|
|
{
|
|
PrintParamError("GlobalVariableSetOnCondition", "name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 1, value, _error))
|
|
{
|
|
PrintParamError("GlobalVariableSetOnCondition", "value", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 2, check_value, _error))
|
|
{
|
|
PrintParamError("GlobalVariableSetOnCondition", "check_value", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool res = GlobalVariableSetOnCondition(name, value, check_value);
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariableSetOnCondition", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariablesDeleteAll()
|
|
{
|
|
string prefix_name;
|
|
StringInit(prefix_name, 250, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, prefix_name, _error))
|
|
{
|
|
PrintParamError("GlobalVariablesDeleteAll", "prefix_name", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendIntResponse(ExpertHandle, GlobalVariablesDeleteAll(prefix_name), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariablesDeleteAll", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_GlobalVariablesTotal()
|
|
{
|
|
if (!sendIntResponse(ExpertHandle, GlobalVariablesTotal(), _response_error))
|
|
{
|
|
PrintResponseError("GlobalVariablesTotal", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iAC()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iAC", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iAC", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iAC", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iAC(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iAC", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iAD()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iAD", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iAD", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iAD", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iAD(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iAD", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iAlligator()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iAD", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iAD", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iAD", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iAD(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iAD", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iADX()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iADX", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iADX", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iADX", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iADX", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, mode, _error))
|
|
{
|
|
PrintParamError("iADX", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, shift, _error))
|
|
{
|
|
PrintParamError("iADX", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iADX(symbol, timeframe, period, applied_price, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iADX", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iATR()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iATR", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iATR", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iATR", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iATR", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iATR(symbol, timeframe, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iATR", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iAO()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iAO", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iAO", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iAO", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iAO(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iAO", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBearsPower()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBearsPower", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBearsPower", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iBearsPower", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iBearsPower", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iBearsPower", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iBearsPower(symbol, timeframe, period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBearsPower", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBands()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int deviation;
|
|
int bands_shift;
|
|
int applied_price;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBands", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBands", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iBands", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, deviation, _error))
|
|
{
|
|
PrintParamError("iBands", "deviation", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, bands_shift, _error))
|
|
{
|
|
PrintParamError("iBands", "bands_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iBands", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, mode, _error))
|
|
{
|
|
PrintParamError("iBands", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 7, shift, _error))
|
|
{
|
|
PrintParamError("iBands", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iBands(symbol, timeframe, period, deviation, bands_shift, applied_price, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBands", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBandsOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int period;
|
|
int deviation;
|
|
int bands_shift;
|
|
int mode;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, period, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, deviation, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "deviation", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, bands_shift, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "bands_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, mode, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iBandsOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iBandsOnArray(doubleArray, total, period, deviation, bands_shift, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBandsOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBullsPower()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBullsPower", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBullsPower", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iBullsPower", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iBullsPower", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iBullsPower", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iBullsPower(symbol, timeframe, period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBullsPower", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iCCI()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iCCI", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iCCI", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iCCI", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iCCI", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iCCI", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iCCI(symbol, timeframe, period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iCCI", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iCCIOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int period;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iCCIOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
getDoubleValue(ExpertHandle, param_index, tempDouble, _error);
|
|
{
|
|
PrintParamError("iCCIOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iCCIOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, period, _error))
|
|
{
|
|
PrintParamError("iCCIOnArray", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iCCIOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iCCIOnArray(doubleArray, total, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iCCIOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iDeMarker()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iDeMarker", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iDeMarker", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iDeMarker", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iDeMarker", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iDeMarker(symbol, timeframe, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iDeMarker", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iEnvelopes()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int ma_period;
|
|
int ma_method;
|
|
int ma_shift;
|
|
int applied_price;
|
|
double deviation;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, ma_period, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "ma_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, ma_method, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, ma_shift, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 6, deviation, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "deviation", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 7, mode, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 8, shift, _error))
|
|
{
|
|
PrintParamError("iEnvelopes", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iEnvelopes(symbol, timeframe, ma_period, ma_method, ma_shift, applied_price, deviation, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iEnvelopes", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iEnvelopesOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int ma_period;
|
|
int ma_method;
|
|
int ma_shift;
|
|
double deviation;
|
|
int mode;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_period, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "ma_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_method, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_shift, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, deviation, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "deviation", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, mode, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iEnvelopesOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iEnvelopesOnArray(doubleArray, total, ma_period, ma_method, ma_shift, deviation, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iEnvelopesOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iForce()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int ma_method;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iForce", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iForce", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iForce", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, ma_method, _error))
|
|
{
|
|
PrintParamError("iForce", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, applied_price, _error))
|
|
{
|
|
PrintParamError("iForce", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, shift, _error))
|
|
{
|
|
PrintParamError("iForce", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iForce(symbol, timeframe, period, ma_method, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iForce", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iFractals()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iFractals", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iFractals", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, mode, _error))
|
|
{
|
|
PrintParamError("iFractals", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iFractals", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iFractals(symbol, timeframe, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iFractals", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iGator()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int jaw_period;
|
|
int jaw_shift;
|
|
int teeth_period;
|
|
int teeth_shift;
|
|
int lips_period;
|
|
int lips_shift;
|
|
int ma_method;
|
|
int applied_price;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iGator", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iGator", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, jaw_period, _error))
|
|
{
|
|
PrintParamError("iGator", "jaw_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, jaw_shift, _error))
|
|
{
|
|
PrintParamError("iGator", "jaw_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, teeth_period, _error))
|
|
{
|
|
PrintParamError("iGator", "teeth_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, teeth_shift, _error))
|
|
{
|
|
PrintParamError("iGator", "teeth_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, lips_period, _error))
|
|
{
|
|
PrintParamError("iGator", "lips_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 7, lips_shift, _error))
|
|
{
|
|
PrintParamError("iGator", "lips_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 8, ma_method, _error))
|
|
{
|
|
PrintParamError("iGator", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 9, applied_price, _error))
|
|
{
|
|
PrintParamError("iGator", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 10, mode, _error))
|
|
{
|
|
PrintParamError("iGator", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 11, shift, _error))
|
|
{
|
|
PrintParamError("iGator", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iGator(symbol, timeframe, jaw_period, jaw_shift, teeth_period, teeth_shift, lips_period, lips_shift, ma_method, applied_price, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iGator", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iIchimoku()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int tenkan_sen;
|
|
int kijun_sen;
|
|
int senkou_span_b;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, tenkan_sen, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "tenkan_sen", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, kijun_sen, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "kijun_sen", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, senkou_span_b, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "senkou_span_b", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, mode, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, shift, _error))
|
|
{
|
|
PrintParamError("iIchimoku", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iIchimoku(symbol, timeframe, tenkan_sen, kijun_sen, senkou_span_b, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iIchimoku", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBWMFI()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBWMFI", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBWMFI", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iBWMFI", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iBWMFI(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBWMFI", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMomentum()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iMomentum", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iMomentum", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iMomentum", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iMomentum", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iMomentum", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMomentum(symbol, timeframe, period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMomentum", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMomentumOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int period;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iMomentumOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iMomentumOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iMomentumOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, period, _error))
|
|
{
|
|
PrintParamError("iMomentumOnArray", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iMomentumOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMomentumOnArray(doubleArray, total, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMomentumOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMFI()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iMFI", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iMFI", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iMFI", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iMFI", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMFI(symbol, timeframe, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMFI", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMA()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int ma_shift;
|
|
int ma_method;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iMA", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iMA", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iMA", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, ma_shift, _error))
|
|
{
|
|
PrintParamError("iMA", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, ma_method, _error))
|
|
{
|
|
PrintParamError("iMA", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iMA", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, shift, _error))
|
|
{
|
|
PrintParamError("iMA", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMA(symbol, timeframe, period, ma_shift, ma_method, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMA", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMAOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int period;
|
|
int ma_shift;
|
|
int ma_method;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, period, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_shift, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_method, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iMAOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMAOnArray(doubleArray, total, period, ma_shift, ma_method, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMAOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iOsMA()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int fast_ema_period;
|
|
int slow_ema_period;
|
|
int signal_period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iOsMA", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iOsMA", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, fast_ema_period, _error))
|
|
{
|
|
PrintParamError("iOsMA", "fast_ema_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, slow_ema_period, _error))
|
|
{
|
|
PrintParamError("iOsMA", "slow_ema_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, signal_period, _error))
|
|
{
|
|
PrintParamError("iOsMA", "signal_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iOsMA", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, shift, _error))
|
|
{
|
|
PrintParamError("iOsMA", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iOsMA(symbol, timeframe, fast_ema_period, slow_ema_period, signal_period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iOsMA", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iMACD()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int fast_ema_period;
|
|
int slow_ema_period;
|
|
int signal_period;
|
|
int applied_price;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iMACD", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iMACD", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, fast_ema_period, _error))
|
|
{
|
|
PrintParamError("iMACD", "fast_ema_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, slow_ema_period, _error))
|
|
{
|
|
PrintParamError("iMACD", "slow_ema_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, signal_period, _error))
|
|
{
|
|
PrintParamError("iMACD", "signal_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iMACD", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, mode, _error))
|
|
{
|
|
PrintParamError("iMACD", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 7, shift, _error))
|
|
{
|
|
PrintParamError("iMACD", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iMACD(symbol, timeframe, fast_ema_period, slow_ema_period, signal_period, applied_price, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iMACD", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iOBV()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iOBV", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iOBV", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, applied_price, _error))
|
|
{
|
|
PrintParamError("iOBV", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iOBV", shift, _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iOBV(symbol, timeframe, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iOBV", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iSAR()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
double step;
|
|
double maximum;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iSAR", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iSAR", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 2, step, _error))
|
|
{
|
|
PrintParamError("iSAR", "step", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getDoubleValue(ExpertHandle, 3, maximum, _error))
|
|
{
|
|
PrintParamError("iSAR", "maximum", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iSAR", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iSAR(symbol, timeframe, step, maximum, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iSAR", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iRSI()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iRSI", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iRSI", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iRSI", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, applied_price, _error))
|
|
{
|
|
PrintParamError("iRSI", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iRSI", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iRSI(symbol, timeframe, period, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iRSI", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iRSIOnArray()
|
|
{
|
|
int array_size = 0;
|
|
double doubleArray[];
|
|
int total;
|
|
int period;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iRSIOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iRSIOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iRSIOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, period, _error))
|
|
{
|
|
PrintParamError("iRSIOnArray", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iRSIOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iRSIOnArray(doubleArray, total, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iRSIOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iRVI()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iRVI", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iRVI", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iRVI", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, mode, _error))
|
|
{
|
|
PrintParamError("iRVI", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, shift, _error))
|
|
{
|
|
PrintParamError("iRVI", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iRVI(symbol, timeframe, period, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iRVI", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iStdDev()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int ma_period;
|
|
int ma_shift;
|
|
int ma_method;
|
|
int applied_price;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iStdDev", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iStdDev", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, ma_period, _error))
|
|
{
|
|
PrintParamError("iStdDev", "ma_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, ma_shift, _error))
|
|
{
|
|
PrintParamError("iStdDev", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, ma_method, _error))
|
|
{
|
|
PrintParamError("iStdDev", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, applied_price, _error))
|
|
{
|
|
PrintParamError("iStdDev", "applied_price", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, shift, _error))
|
|
{
|
|
PrintParamError("iStdDev", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iStdDev(symbol, timeframe, ma_period, ma_shift, ma_method, applied_price, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iStdDev", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iStdDevOnArray()
|
|
{
|
|
int array_size;
|
|
double doubleArray[];
|
|
int total;
|
|
int ma_period;
|
|
int ma_shift;
|
|
int ma_method;
|
|
int shift;
|
|
|
|
int param_index = 0;
|
|
if (!getIntValue(ExpertHandle, param_index, array_size, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "array_size", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ArrayResize(doubleArray, array_size);
|
|
|
|
for(int i = 0; i < array_size; i++)
|
|
{
|
|
double tempDouble;
|
|
param_index++;
|
|
if (!getDoubleValue(ExpertHandle, param_index, tempDouble, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "array", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
doubleArray[i] = tempDouble;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, total, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "total", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_period, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "ma_period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_shift, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "ma_shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, ma_method, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "ma_method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
param_index++;
|
|
if (!getIntValue(ExpertHandle, param_index, shift, _error))
|
|
{
|
|
PrintParamError("iStdDevOnArray", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iStdDevOnArray(doubleArray, total, ma_period, ma_shift, ma_method, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iStdDevOnArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iStochastic()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int kperiod;
|
|
int dperiod;
|
|
int slowing;
|
|
int method;
|
|
int price_field;
|
|
int mode;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iStochastic", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iStochastic", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, kperiod, _error))
|
|
{
|
|
PrintParamError("iStochastic", "Kperiod", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, dperiod, _error))
|
|
{
|
|
PrintParamError("iStochastic", "Dperiod", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, slowing, _error))
|
|
{
|
|
PrintParamError("iStochastic", "slowing", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 5, method, _error))
|
|
{
|
|
PrintParamError("iStochastic", "method", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 6, price_field, _error))
|
|
{
|
|
PrintParamError("iStochastic", "price_field", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 7, mode, _error))
|
|
{
|
|
PrintParamError("iStochastic", "mode", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 8, shift, _error))
|
|
{
|
|
PrintParamError("iStochastic", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iStochastic(symbol, timeframe, kperiod, dperiod, slowing, method, price_field, mode, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iStochastic", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iWPR()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int period;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iWPR", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iWPR", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, period, _error))
|
|
{
|
|
PrintParamError("iWPR", "period", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, shift, _error))
|
|
{
|
|
PrintParamError("iWPR", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iWPR(symbol, timeframe, period, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iWPR", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBars()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBars", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBars", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = iBars(symbol, timeframe);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBars", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iBarShift()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int time;
|
|
int exact;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iBarShift", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iBarShift", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, time, _error))
|
|
{
|
|
PrintParamError("iBarShift", "time", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, exact, _error))
|
|
{
|
|
PrintParamError("iBarShift", "exact", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = iBarShift(symbol, timeframe, time, exact);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iBarShift", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iClose()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iClose", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iClose", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iClose", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iClose(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iClose", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iHigh()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iHigh", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iHigh", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iHigh", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iHigh(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iHigh", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iHighest()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int type;
|
|
int count;
|
|
int start_value;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iHighest", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iHighest", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, type, _error))
|
|
{
|
|
PrintParamError("iHighest", "type", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, count, _error))
|
|
{
|
|
PrintParamError("iHighest", "count", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, start_value, _error))
|
|
{
|
|
PrintParamError("iHighest", "start", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = iHighest(symbol, timeframe, type, count, start_value);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iHighest", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iLow()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iLow", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iLow", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iLow", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iLow(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iLow", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iLowest()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int type;
|
|
int count;
|
|
int start_value;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iLowest", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iLowest", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, type, _error))
|
|
{
|
|
PrintParamError("iLowest", "type", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 3, count, _error))
|
|
{
|
|
PrintParamError("iLowest", "count", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 4, start_value, _error))
|
|
{
|
|
PrintParamError("iLowest", "start", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res= iLowest(symbol, timeframe, type, count, start_value);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iLowest", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iOpen()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iOpen", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iOpen", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iOpen", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iOpen(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iOpen", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iTime()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iTime", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iTime", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iTime", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = iTime(symbol, timeframe, shift);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iTime", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iVolume()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
int shift;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iVolume", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iVolume", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 2, shift, _error))
|
|
{
|
|
PrintParamError("iVolume", "shift", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = iVolume(symbol, timeframe, shift);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("iVolume", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iCloseArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iCloseArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iCloseArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double priceArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int priceCount = ArrayResize(priceArray, barsCount);
|
|
|
|
for(int i = 0; i < priceCount; i++)
|
|
{
|
|
priceArray[i] = iClose(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendDoubleArrayResponse(ExpertHandle, priceArray, priceCount, _response_error))
|
|
{
|
|
PrintResponseError("iCloseArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iHighArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iHighArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iHighArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double priceArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int priceCount = ArrayResize(priceArray, barsCount);
|
|
|
|
for(int i = 0; i < priceCount; i++)
|
|
{
|
|
priceArray[i] = iHigh(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendDoubleArrayResponse(ExpertHandle, priceArray, priceCount, _response_error))
|
|
{
|
|
PrintResponseError("iHighArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iLowArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iLowArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iOpenArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double priceArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int priceCount = ArrayResize(priceArray, barsCount);
|
|
|
|
for(int i = 0; i < priceCount; i++)
|
|
{
|
|
priceArray[i] = iLow(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendDoubleArrayResponse(ExpertHandle, priceArray, priceCount, _response_error))
|
|
{
|
|
PrintResponseError("iLowArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iOpenArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iOpenArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iOpenArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double priceArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int priceCount = ArrayResize(priceArray, barsCount);
|
|
|
|
for(int i = 0; i < priceCount; i++)
|
|
{
|
|
priceArray[i] = iOpen(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendDoubleArrayResponse(ExpertHandle, priceArray, priceCount, _response_error))
|
|
{
|
|
PrintResponseError("iOpenArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iVolumeArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iVolumeArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iVolumeArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double volumeArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int volumeCount = ArrayResize(volumeArray, barsCount);
|
|
|
|
for(int i = 0; i < volumeCount; i++)
|
|
{
|
|
volumeArray[i] = iVolume(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendDoubleArrayResponse(ExpertHandle, volumeArray, volumeCount, _response_error))
|
|
{
|
|
PrintResponseError("iVolumeArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_iTimeArray()
|
|
{
|
|
string symbol;
|
|
int timeframe;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("iTimeArray", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, timeframe, _error))
|
|
{
|
|
PrintParamError("iTimeArray", "timeframe", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int timeArray[];
|
|
int barsCount = iBars(symbol, timeframe);
|
|
int timeCount = ArrayResize(timeArray, barsCount);
|
|
|
|
for(int i = 0; i < timeCount; i++)
|
|
{
|
|
timeArray[i] = iTime(symbol, timeframe, i);
|
|
}
|
|
|
|
if (!sendIntArrayResponse(ExpertHandle, timeArray, timeCount, _response_error))
|
|
{
|
|
PrintResponseError("iTimeArray", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_RefreshRates()
|
|
{
|
|
bool res = RefreshRates();
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("RefreshRates", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalInfoString()
|
|
{
|
|
int type;
|
|
|
|
if (getIntValue(ExpertHandle, 0, type, _error))
|
|
{
|
|
PrintParamError("TerminalInfoString", "type", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
string res = TerminalInfoString(type);
|
|
|
|
if (!sendStringResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("TerminalInfoString", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SymbolInfoString()
|
|
{
|
|
string symbol;
|
|
int propId;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("SymbolInfoString", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (getIntValue(ExpertHandle, 1, propId, _error))
|
|
{
|
|
PrintParamError("SymbolInfoString", "propId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
string res = SymbolInfoString(symbol, propId);
|
|
|
|
if (!sendStringResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("SymbolInfoString", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_BacktestingReady()
|
|
{
|
|
if (IsTesting())
|
|
{
|
|
Print("Remote client is ready for backteting");
|
|
IsRemoteReadyForTesting = true;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, IsRemoteReadyForTesting, _response_error))
|
|
{
|
|
PrintResponseError("BacktestingReady", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SymbolsTotal()
|
|
{
|
|
bool select;
|
|
|
|
if (!getBooleanValue(ExpertHandle, 0, select, _error))
|
|
{
|
|
PrintParamError("SymbolsTotal", "select", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = SymbolsTotal(select);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("SymbolsTotal", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SymbolName()
|
|
{
|
|
int index;
|
|
bool select;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, index, _error))
|
|
{
|
|
PrintParamError("SymbolName", "index", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getBooleanValue(ExpertHandle, 1, select, _error))
|
|
{
|
|
PrintParamError("SymbolName", "select", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
string res = SymbolName(index, select);
|
|
|
|
if (!sendStringResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("SymbolName", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SymbolSelect()
|
|
{
|
|
string symbol;
|
|
bool select;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("SymbolSelect", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getBooleanValue(ExpertHandle, 1, select, _error))
|
|
{
|
|
PrintParamError("SymbolSelect", "select", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
bool res = SymbolSelect(symbol, select);
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("SymbolSelect", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_SymbolInfoInteger()
|
|
{
|
|
string symbol;
|
|
int propId;
|
|
StringInit(symbol, 100, 0);
|
|
|
|
if (!getStringValue(ExpertHandle, 0, symbol, _error))
|
|
{
|
|
PrintParamError("SymbolInfoInteger", "symbol", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getIntValue(ExpertHandle, 1, propId, _error))
|
|
{
|
|
PrintParamError("SymbolInfoInteger", "propId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
long res = SymbolInfoInteger(symbol, propId);
|
|
|
|
if (!sendLongResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("SymbolInfoInteger", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalInfoInteger()
|
|
{
|
|
int propId;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, propId, _error))
|
|
{
|
|
PrintParamError("TerminalInfoInteger", "propId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
int res = TerminalInfoInteger(propId);
|
|
|
|
if (!sendIntResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("TerminalInfoInteger", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_TerminalInfoDouble()
|
|
{
|
|
int propId;
|
|
|
|
if (!getIntValue(ExpertHandle, 0, propId, _error))
|
|
{
|
|
PrintParamError("TerminalInfoDouble", "propId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
double res = TerminalInfoDouble(propId);
|
|
|
|
if (!sendDoubleResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("TerminalInfoDouble", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_CharId()
|
|
{
|
|
long res = ChartID();
|
|
|
|
if (!sendLongResponse(ExpertHandle, res, _response_error))
|
|
{
|
|
PrintResponseError("ChartId", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_ChartRedraw()
|
|
{
|
|
long chartId;
|
|
|
|
if (!getLongValue(ExpertHandle, 0, chartId, _error))
|
|
{
|
|
PrintParamError("ChartRedraw", "chartId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
ChartRedraw(chartId);
|
|
|
|
if (!sendVoidResponse(ExpertHandle, _response_error))
|
|
{
|
|
PrintResponseError("ChartRedraw", _response_error);
|
|
}
|
|
}
|
|
|
|
void Execute_ObjectCreate()
|
|
{
|
|
long chartId;
|
|
string objectName;
|
|
int objectType;
|
|
int subWindow;
|
|
int time1;
|
|
double price1;
|
|
int time2 = 0;
|
|
double price2 = 0;
|
|
int time3 = 0;
|
|
double price3 = 0;
|
|
StringInit(objectName, 200);
|
|
|
|
if (!getNamedLongValue(ExpertHandle, "chartId", chartId, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "chartId", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getNamedStringValue(ExpertHandle, "objectName", objectName, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "objectName", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getNamedIntValue(ExpertHandle, "objectType", objectType, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "objectType", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getNamedIntValue(ExpertHandle, "subWindow", subWindow, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "subWindow", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getNamedIntValue(ExpertHandle, "time1", time1, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "time1", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!getNamedDoubleValue(ExpertHandle, "price1", price1, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "price1", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (containsNamedValue(ExpertHandle, "time2"))
|
|
{
|
|
if (!getNamedIntValue(ExpertHandle, "time2", time2, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "time2", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (containsNamedValue(ExpertHandle, "price2"))
|
|
{
|
|
if (!getNamedDoubleValue(ExpertHandle, "price2", price2, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "price2", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (containsNamedValue(ExpertHandle, "time3"))
|
|
{
|
|
if (!getNamedIntValue(ExpertHandle, "time3", time3, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "time3", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (containsNamedValue(ExpertHandle, "price3"))
|
|
{
|
|
if (!getNamedDoubleValue(ExpertHandle, "price3", price3, _error))
|
|
{
|
|
PrintParamError("ObjectCreate", "price3", _error);
|
|
sendErrorResponse(ExpertHandle, -1, _error, _response_error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
PrintFormat("ObjectCreate: chartId = %d, objectName = %s, objectType = %d, subWindow = %d, time1 = %d, price1 = %f, time2 = %d, price2 = %f, time3 = %d, price3 = %f, ",
|
|
chartId, objectName, objectType, subWindow, time1, price1, time2, price2, time3, price3);
|
|
|
|
bool res = ObjectCreate(chartId, objectName, objectType, subWindow, time1, price1, time2, price2, time3, price3);
|
|
|
|
if(!res)
|
|
{
|
|
int last_error = GetLastError();
|
|
PrintFormat("[ERROR] ObjectCreate: Failed! ErrorCode = %d", last_error);
|
|
sendErrorResponse(ExpertHandle, last_error, _error, _response_error);
|
|
return;
|
|
}
|
|
|
|
if (!sendBooleanResponse(ExpertHandle, true, _response_error))
|
|
{
|
|
PrintResponseError("ObjectCreate", _response_error);
|
|
}
|
|
}
|
|
|
|
void PrintParamError(string paramName)
|
|
{
|
|
PrintFormat("[ERROR] parameter: %s.", paramName);
|
|
}
|
|
|
|
void PrintParamError(string commandName, string paramName, string error)
|
|
{
|
|
PrintFormat("[ERROR] Command: %s, parameter: %s. %s", commandName, paramName, error);
|
|
}
|
|
|
|
void PrintResponseError(string commandName, string error = "")
|
|
{
|
|
PrintFormat("[ERROR] response: %s. %s", commandName, error);
|
|
}
|
|
|
|
bool OrderCloseAll()
|
|
{
|
|
int total = OrdersTotal();
|
|
for(int i = total-1; i >= 0; i--)
|
|
{
|
|
if (OrderSelect(i, SELECT_BY_POS))
|
|
{
|
|
int type = OrderType();
|
|
switch(type)
|
|
{
|
|
//Close opened long positions
|
|
case OP_BUY: OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );
|
|
break;
|
|
//Close opened short positions
|
|
case OP_SELL: OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
|
|
string CreateErrorResponse(int code, string error)
|
|
{
|
|
JSONObject *joResponse = new JSONObject();
|
|
joResponse.put("ErrorCode", new JSONNumber(code));
|
|
joResponse.put("ErrorMessage", new JSONString(error));
|
|
|
|
string res = joResponse.toString();
|
|
delete joResponse;
|
|
return res;
|
|
}
|
|
|
|
string CreateSuccessResponse(string responseName, JSONValue* responseBody)
|
|
{
|
|
JSONObject *joResponse = new JSONObject();
|
|
joResponse.put("ErrorCode", new JSONNumber(ERR_NO_ERROR));
|
|
|
|
if (responseBody != NULL)
|
|
{
|
|
joResponse.put(responseName, responseBody);
|
|
}
|
|
|
|
string res = joResponse.toString();
|
|
delete joResponse;
|
|
return res;
|
|
}
|
|
|
|
string OnRequest(string json)
|
|
{
|
|
string response = "";
|
|
|
|
JSONParser *parser = new JSONParser();
|
|
JSONValue *jv = parser.parse(json);
|
|
|
|
if(jv == NULL)
|
|
{
|
|
Print("OnRequest [ERROR]:" + (string)parser.getErrorCode() + parser.getErrorMessage());
|
|
}
|
|
else
|
|
{
|
|
if(jv.isObject())
|
|
{
|
|
JSONObject *jo = jv;
|
|
int requestType = jo.getInt("RequestType");
|
|
|
|
Print("OnRequest: RequestType = ", requestType);
|
|
switch(requestType)
|
|
{
|
|
case 1: //GetOrder
|
|
response = ExecuteRequest_GetOrder(jo);
|
|
break;
|
|
case 2: //GetOrders
|
|
response = ExecuteRequest_GetOrders(jo);
|
|
break;
|
|
case 3: //OrderSend
|
|
response = ExecuteRequest_OrderSend(jo);
|
|
break;
|
|
case 4: //OrderClose
|
|
response = ExecuteRequest_OrderClose(jo);
|
|
break;
|
|
case 5: //OrderCloseBy
|
|
response = ExecuteRequest_OrderCloseBy(jo);
|
|
break;
|
|
case 6: //OrderDelete
|
|
response = ExecuteRequest_OrderDelete(jo);
|
|
break;
|
|
case 7: //OrderModify
|
|
response = ExecuteRequest_OrderModify(jo);
|
|
break;
|
|
case 8: //iCustom
|
|
response = ExecuteRequest_iCustom(jo);
|
|
break;
|
|
case 9: //CopyRates
|
|
response = ExecuteRequest_CopyRates(jo);
|
|
break;
|
|
case 10: //Session
|
|
response = ExecuteRequest_Session(jo);
|
|
break;
|
|
case 11: //SeriesInfoInteger
|
|
response = ExecuteRequest_SeriesInfoInteger(jo);
|
|
break;
|
|
case 12: //SymbolInfoDouble
|
|
response = ExecuteRequest_SymbolInfoDouble(jo);
|
|
break;
|
|
case 13: //SymbolInfoTick
|
|
response = ExecuteRequest_SymbolInfoTick(jo);
|
|
break;
|
|
default:
|
|
Print("OnRequest [WARNING]: Unknown request type ", requestType);
|
|
response = CreateErrorResponse(-1, "Unknown request type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete jv;
|
|
}
|
|
|
|
delete parser;
|
|
|
|
Print("OnRequest: Response = ", response);
|
|
|
|
return response;
|
|
}
|
|
|
|
string ExecuteRequest_GetOrder(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Index") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Index");
|
|
if (jo.getValue("Select") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Select");
|
|
if (jo.getValue("Pool") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Pool");
|
|
|
|
int index = jo.getInt("Index");
|
|
int select = jo.getInt("Select");
|
|
int pool = jo.getInt("Pool");
|
|
|
|
MtOrder* order = MtOrder::LoadOrder(index, select, pool);
|
|
if (order == NULL)
|
|
return CreateErrorResponse(GetLastError(), "GetOrder failed");
|
|
|
|
string response = CreateSuccessResponse("Order", order.CreateJson());
|
|
delete order;
|
|
|
|
return response;
|
|
}
|
|
|
|
string ExecuteRequest_GetOrders(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Pool") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Pool");
|
|
|
|
int pool = jo.getInt("Pool");
|
|
|
|
int total = (pool == MODE_HISTORY) ? OrdersHistoryTotal() : OrdersTotal();
|
|
|
|
JSONArray* joOrders = new JSONArray();
|
|
for(int pos = 0; pos < total; pos++)
|
|
{
|
|
MtOrder* order = MtOrder::LoadOrder(pos, SELECT_BY_POS, pool);
|
|
if (order == NULL)
|
|
{
|
|
delete joOrders;
|
|
return CreateErrorResponse(GetLastError(), "GetOrders failed");
|
|
}
|
|
|
|
joOrders.put(pos, order.CreateJson());
|
|
delete order;
|
|
}
|
|
|
|
return CreateSuccessResponse("Orders", joOrders);
|
|
}
|
|
|
|
string ExecuteRequest_OrderSend(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Symbol") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Symbol");
|
|
if (jo.getValue("Cmd") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Cmd");
|
|
if (jo.getValue("Volume") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Volume");
|
|
|
|
string symbol = jo.getString("Symbol");
|
|
int cmd = jo.getInt("Cmd");
|
|
double volume = jo.getDouble("Volume");
|
|
|
|
double price;
|
|
|
|
JSONValue *jvPrice = jo.getValue("Price");
|
|
if (jvPrice != NULL)
|
|
{
|
|
price = jvPrice.getDouble();
|
|
}
|
|
else
|
|
{
|
|
int mode = MtOrder::isLong(cmd) ? MODE_ASK : MODE_BID;
|
|
price = MarketInfo(symbol, mode);
|
|
}
|
|
|
|
JSONValue *jvSlippage = jo.getValue("Slippage");
|
|
double slippage = (jvSlippage != NULL) ? jvSlippage.getDouble() : 1;
|
|
|
|
JSONValue *jvStoploss = jo.getValue("Stoploss");
|
|
double stoploss = (jvStoploss != NULL) ? jvStoploss.getDouble() : 0;
|
|
|
|
JSONValue *jvTakeprofit = jo.getValue("Takeprofit");
|
|
double takeprofit = (jvTakeprofit != NULL) ? jvTakeprofit.getDouble() : 0;
|
|
|
|
JSONValue *jvComment = jo.getValue("Comment");
|
|
string comment = (jvComment != NULL) ? jvComment.getString() : NULL;
|
|
|
|
JSONValue *jvMagic = jo.getValue("Magic");
|
|
int magic = (jvMagic != NULL) ? jvMagic.getInt() : 0;
|
|
|
|
JSONValue *jvExpiration = jo.getValue("Expiration");
|
|
int expiration = (jvExpiration != NULL) ? jvExpiration.getInt() : 0;
|
|
|
|
JSONValue *jvArrowColor = jo.getValue("ArrowColor");
|
|
int arrowcolor = (jvArrowColor != NULL) ? jvArrowColor.getInt() : clrNONE;
|
|
|
|
int ticket = OrderSend(symbol, cmd, volume, price, slippage, stoploss, takeprofit, comment, magic, expiration, arrowcolor);
|
|
if(ticket < 0)
|
|
return CreateErrorResponse(GetLastError(), "OrderSend failed");
|
|
|
|
JSONValue* jvTicket = new JSONNumber(ticket);
|
|
return CreateSuccessResponse("Ticket", jvTicket);
|
|
}
|
|
|
|
string ExecuteRequest_OrderClose(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Ticket") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Ticket");
|
|
|
|
int ticket = jo.getInt("Ticket");
|
|
|
|
double price;
|
|
JSONValue *jvPrice = jo.getValue("Price");
|
|
if (jvPrice != NULL)
|
|
{
|
|
price = jvPrice.getDouble();
|
|
}
|
|
else
|
|
{
|
|
if (OrderSelect(ticket, SELECT_BY_TICKET))
|
|
{
|
|
string symbol = OrderSymbol();
|
|
int mode = MtOrder::isLong(OrderType()) ? MODE_BID : MODE_ASK;
|
|
price = MarketInfo(symbol, mode);
|
|
}
|
|
else
|
|
{
|
|
return CreateErrorResponse(-1, "Failed select order to get current price");
|
|
}
|
|
}
|
|
|
|
double lots;
|
|
JSONValue *jvLots = jo.getValue("Lots");
|
|
if (jvLots != NULL)
|
|
{
|
|
lots = jvLots.getDouble();
|
|
}
|
|
else
|
|
{
|
|
if (OrderSelect(ticket, SELECT_BY_TICKET))
|
|
{
|
|
lots = OrderLots();
|
|
}
|
|
else
|
|
{
|
|
return CreateErrorResponse(-1, "Failed select order to get lots of order");
|
|
}
|
|
}
|
|
|
|
JSONValue *jvSlippage = jo.getValue("Slippage");
|
|
double slippage = (jvSlippage != NULL) ? jvSlippage.getDouble() : 1;
|
|
|
|
JSONValue *jvArrowColor = jo.getValue("ArrowColor");
|
|
int arrowcolor = (jvArrowColor != NULL) ? jvArrowColor.getInt() : clrNONE;
|
|
|
|
if (!OrderClose(ticket, lots, price, slippage, arrowcolor))
|
|
return CreateErrorResponse(GetLastError(), "OrderClose failed");
|
|
return CreateSuccessResponse("", NULL);
|
|
}
|
|
|
|
string ExecuteRequest_OrderCloseBy(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Ticket") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Ticket");
|
|
if (jo.getValue("Opposite") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Opposite");
|
|
|
|
int ticket = jo.getInt("Ticket");
|
|
int opposite = jo.getInt("Opposite");
|
|
|
|
JSONValue *jvArrowColor = jo.getValue("ArrowColor");
|
|
int arrowcolor = (jvArrowColor != NULL) ? jvArrowColor.getInt() : CLR_NONE;
|
|
|
|
if (!OrderCloseBy(ticket, opposite, arrowcolor))
|
|
return CreateErrorResponse(GetLastError(), "OrderCloseBy failed");
|
|
return CreateSuccessResponse("", NULL);
|
|
}
|
|
|
|
string ExecuteRequest_OrderDelete(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Ticket") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Ticket");
|
|
|
|
int ticket = jo.getInt("Ticket");
|
|
|
|
JSONValue *jvArrowColor = jo.getValue("ArrowColor");
|
|
int arrowcolor = (jvArrowColor != NULL) ? jvArrowColor.getInt() : CLR_NONE;
|
|
|
|
if (!OrderDelete(ticket, arrowcolor))
|
|
return CreateErrorResponse(GetLastError(), "OrderDelete failed");
|
|
return CreateSuccessResponse("", NULL);
|
|
}
|
|
|
|
string ExecuteRequest_OrderModify(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Ticket") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Ticket");
|
|
if (jo.getValue("Price") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Price");
|
|
if (jo.getValue("Stoploss") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Stoploss");
|
|
if (jo.getValue("Takeprofit") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Takeprofit");
|
|
if (jo.getValue("Expiration") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Expiration");
|
|
|
|
int ticket = jo.getInt("Ticket");
|
|
double price = jo.getDouble("Price");
|
|
double stoploss = jo.getDouble("Stoploss");
|
|
double takeprofit = jo.getDouble("Takeprofit");
|
|
int expiration = jo.getInt("Expiration");
|
|
|
|
JSONValue *jvArrowColor = jo.getValue("ArrowColor");
|
|
int arrowcolor = (jvArrowColor != NULL) ? jvArrowColor.getInt() : CLR_NONE;
|
|
|
|
if (!OrderModify(ticket, price, stoploss, takeprofit, expiration, arrowcolor))
|
|
return CreateErrorResponse(GetLastError(), "OrderModify failed");
|
|
return CreateSuccessResponse("", NULL);
|
|
}
|
|
|
|
string ExecuteRequest_iCustom(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Symbol") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Symbol");
|
|
if (jo.getValue("Timeframe") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Timeframe");
|
|
if (jo.getValue("Name") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Name");
|
|
if (jo.getValue("Mode") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Mode");
|
|
if (jo.getValue("Shift") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Shift");
|
|
|
|
string symbol = jo.getString("Symbol");
|
|
int timeframe = jo.getInt("Timeframe");
|
|
string name = jo.getString("Name");
|
|
int mode = jo.getInt("Mode");
|
|
int shift = jo.getInt("Shift");
|
|
|
|
double result;
|
|
|
|
if (jo.getValue("Params") == NULL)
|
|
{
|
|
result = iCustom(symbol, timeframe, name, mode, shift);
|
|
}
|
|
else
|
|
{
|
|
JSONArray *jaParams = jo.getArray("Params");
|
|
int size = jaParams.size();
|
|
|
|
if (size < 0 || size > 10)
|
|
return CreateErrorResponse(-1, "Parameter's count is out of range.");
|
|
|
|
if (jo.getValue("ParamsType") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter ParamsType");
|
|
|
|
int paramsType = jo.getInt("ParamsType");
|
|
switch (paramsType)
|
|
{
|
|
case 0: //Int
|
|
{
|
|
int intParams[];
|
|
ArrayResize(intParams, size);
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
intParams[i] = jaParams.getInt(i);
|
|
}
|
|
result = iCustomT(symbol, timeframe, name, intParams, size, mode, shift);
|
|
}
|
|
break;
|
|
case 1: //Double
|
|
{
|
|
int doubleParams[];
|
|
ArrayResize(doubleParams, size);
|
|
result = iCustomT(symbol, timeframe, name, doubleParams, size, mode, shift);
|
|
}
|
|
break;
|
|
case 2: //String
|
|
{
|
|
string stringParams[];
|
|
ArrayResize(stringParams, size);
|
|
result = iCustomT(symbol, timeframe, name, stringParams, size, mode, shift);
|
|
}
|
|
break;
|
|
case 3: //Boolean
|
|
{
|
|
string boolParams[];
|
|
ArrayResize(boolParams, size);
|
|
result = iCustomT(symbol, timeframe, name, boolParams, size, mode, shift);
|
|
}
|
|
break;
|
|
default:
|
|
return CreateErrorResponse(-1, "Unsupported type of iCustom parameters.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return CreateSuccessResponse("Value", new JSONNumber(result));
|
|
}
|
|
|
|
template<typename T>
|
|
double iCustomT(string symbol, int timeframe, string name, T &p[], int count, int mode, int shift)
|
|
{
|
|
switch(count)
|
|
{
|
|
case 0:
|
|
return iCustom(symbol, timeframe, name, mode, shift);
|
|
break;
|
|
case 1:
|
|
return iCustom(symbol, timeframe, name, p[0], mode, shift);
|
|
case 2:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], mode, shift);
|
|
case 3:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], mode, shift);
|
|
case 4:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], mode, shift);
|
|
case 5:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], mode, shift);
|
|
case 6:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], p[5], mode, shift);
|
|
case 7:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], p[5], p[6], mode, shift);
|
|
case 8:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], mode, shift);
|
|
case 9:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], mode, shift);
|
|
case 10:
|
|
return iCustom(symbol, timeframe, name, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], mode, shift);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
string ExecuteRequest_CopyRates(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Timeframe") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Timeframe");
|
|
if (jo.getValue("SymbolName") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter SymbolName");
|
|
if (jo.getValue("CopyRatesType") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter CopyRatesType");
|
|
|
|
string symbolName = jo.getString("SymbolName");
|
|
int timeFrame = jo.getInt("Timeframe");
|
|
int copyRatesType = jo.getInt("CopyRatesType");
|
|
|
|
MqlRates rates[];
|
|
ArraySetAsSeries(rates,true);
|
|
int copied = 0;
|
|
|
|
if (copyRatesType == 1)
|
|
{
|
|
if (jo.getValue("StartPos") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter StartPos");
|
|
if (jo.getValue("Count") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Count");
|
|
|
|
copied = CopyRates(symbolName, timeFrame, jo.getInt("StartPos"), jo.getInt("Count"), rates);
|
|
}
|
|
else if (copyRatesType == 2)
|
|
{
|
|
if (jo.getValue("StartTime") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter StartTime");
|
|
if (jo.getValue("Count") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Count");
|
|
|
|
copied = CopyRates(symbolName, timeFrame, (datetime)jo.getInt("StartTime"), jo.getInt("Count"), rates);
|
|
}
|
|
else if (copyRatesType == 3)
|
|
{
|
|
if (jo.getValue("StartTime") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter StartTime");
|
|
if (jo.getValue("StopTime") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter StopTime");
|
|
|
|
copied = CopyRates(symbolName, timeFrame, (datetime)jo.getInt("StartTime"), (datetime)jo.getInt("StopTime"), rates);
|
|
}
|
|
else
|
|
{
|
|
return CreateErrorResponse(-1, "Unsupported type of CopyRates.");
|
|
}
|
|
|
|
if(copied < 0)
|
|
{
|
|
return CreateErrorResponse(GetLastError(), "CopyRates failed.");
|
|
}
|
|
|
|
JSONArray* jaRates = new JSONArray();
|
|
for(int i = 0; i < copied; i++)
|
|
{
|
|
JSONObject *joRate = new JSONObject();
|
|
joRate.put("MtTime", new JSONNumber(rates[i].time));
|
|
joRate.put("Open", new JSONNumber(rates[i].open));
|
|
joRate.put("High", new JSONNumber(rates[i].high));
|
|
joRate.put("Low", new JSONNumber(rates[i].low));
|
|
joRate.put("Close", new JSONNumber(rates[i].close));
|
|
joRate.put("TickVolume", new JSONNumber(rates[i].tick_volume));
|
|
joRate.put("Spread", new JSONNumber(rates[i].spread));
|
|
joRate.put("RealVolume", new JSONNumber(rates[i].real_volume));
|
|
|
|
jaRates.put(i, joRate);
|
|
}
|
|
|
|
return CreateSuccessResponse("Rates", jaRates);
|
|
}
|
|
|
|
string ExecuteRequest_Session(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Symbol") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Symbol");
|
|
if (jo.getValue("DayOfWeek") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter DayOfWeek");
|
|
if (jo.getValue("SessionIndex") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter SessionIndex");
|
|
if (jo.getValue("SessionType") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter SessionType");
|
|
|
|
string symbolName = jo.getString("Symbol");
|
|
int dayOfWeek = jo.getInt("DayOfWeek");
|
|
int sessionIndex = jo.getInt("SessionIndex");
|
|
int sessionType = jo.getInt("SessionType");
|
|
|
|
MtSession* session = MtSession::LoadSession(symbolName, dayOfWeek, sessionIndex, sessionType);
|
|
string responce = CreateSuccessResponse("Session", session.CreateJson());
|
|
delete session;
|
|
|
|
return responce;
|
|
}
|
|
|
|
string ExecuteRequest_SeriesInfoInteger(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("SymbolName") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter SymbolName");
|
|
if (jo.getValue("Timeframe") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Timeframe");
|
|
if (jo.getValue("PropId") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter PropId");
|
|
|
|
string symbolName = jo.getString("SymbolName");
|
|
int timeframe = jo.getInt("Timeframe");
|
|
int propId = jo.getInt("PropId");
|
|
|
|
long value = 0;
|
|
if (!SeriesInfoInteger(symbolName, timeframe, propId, value))
|
|
return CreateErrorResponse(GetLastError(), "SeriesInfoInteger failed");
|
|
|
|
return CreateSuccessResponse("Value", new JSONNumber(value));
|
|
}
|
|
|
|
string ExecuteRequest_SymbolInfoDouble(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("SymbolName") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter SymbolName");
|
|
if (jo.getValue("PropId") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter PropId");
|
|
|
|
string symbolName = jo.getString("SymbolName");
|
|
int propId = jo.getInt("PropId");
|
|
|
|
double value = 0;
|
|
if (!SymbolInfoDouble(symbolName, propId, value))
|
|
return CreateErrorResponse(GetLastError(), "SymbolInfoDouble failed");
|
|
|
|
return CreateSuccessResponse("Value", new JSONNumber(value));
|
|
}
|
|
|
|
string ExecuteRequest_SymbolInfoTick(JSONObject *jo)
|
|
{
|
|
if (jo.getValue("Symbol") == NULL)
|
|
return CreateErrorResponse(-1, "Undefinded mandatory parameter Symbol");
|
|
|
|
string symbol = jo.getString("Symbol");
|
|
|
|
MqlTick tick;
|
|
if (!SymbolInfoTick(symbol, tick))
|
|
return CreateErrorResponse(GetLastError(), "SymbolInfoDouble failed");
|
|
|
|
JSONObject *joTick = new JSONObject();
|
|
joTick.put("MtTime", new JSONNumber(tick.time));
|
|
joTick.put("Bid", new JSONNumber(tick.bid));
|
|
joTick.put("Ask", new JSONNumber(tick.ask));
|
|
joTick.put("Last", new JSONNumber(tick.last));
|
|
joTick.put("Volume", new JSONNumber(tick.volume));
|
|
|
|
return CreateSuccessResponse("Tick", joTick);
|
|
} |