Costruire una startup di tecnologia sociale, parte I: Twitta i tuoi segnali MetaTrader 5
70
0
Introduzione
Questo articolo si propone di illustrare, attraverso un esempio pratico, come è possibile mettere in comunicazione un terminale MetaTrader 5 con un servizio web esterno. Stiamo twittando i segnali di trading generati da un Expert Advisor.
Questa idea nasce da una particolare concezione del trading automatico chiamato trading assistito da un computer. In poche parole, i computer del XXI secolo non hanno capacità cognitive, ma sono molto bravi a elaborare informazioni ed eseguire dati. Allora perché non costruire sistemi informatici utilizzando cervelli umani come filtri per prendere decisioni? Questo approccio è ispirato al paradigma Human-based computation (HBC), quindi si concentra sulla costruzione di strumenti di supporto decisionale, piuttosto che sulla codifica di algoritmi di decision makers.
Inizialmente avevo pensato di creare un feed RSS con i segnali di trading generati dai miei EA (presumendo che ci sia un sistema di trading sottostante a medio o lungo termine, questa idea non è valida per i sistemi di scalping automatico). Un essere umano con accesso al feed dovrebbe convalidare i miei segnali robotici in base alle circostanze del momento, appena prima di immetterli sul mercato. Tuttavia, mi sono presto reso conto che tutto poteva essere ancora più social e ho pensato tra me e me: 'Perché non pubblicare i miei segnali di trading su Twitter?' Questo mi ha portato a sviluppare questo Social Decision Support System.
Figure 1. Architettura SDSS
A proposito, se hai intenzione di creare una startup tecnologica legata al trading FX questo articolo può darti alcune idee. Può essere visto come una guida tecnica per costruire un SaaS (Software as a Service) commerciale basato su un SDSS.
Questo testo è lungo, quindi ho deciso di dividerlo in due parti. Il primo è incentrato sull'architettura del servizio web, sul protocollo di comunicazione utilizzato tra il terminale MetaTrader 5 e l'app Twitter e, infine, sull'integrazione dell'app web con Twitter. La seconda parte riguarderà il livello MQL5 del diagramma di rete mostrato sopra, che è destinato a consumare il servizio web RESTful del nostro sistema di supporto alle decisioni sociali (SDSS). Nello specifico, codificheremo un framework MQL5-RESTful nello stesso modo spiegato nell'articolo MQL5-RPC. Chiamate di procedura remota da MQL5: Accesso al servizio Web e analizzatore ATC XML-RPC per divertimento e profitto.
Questo articolo è anche social, quindi ti incoraggio a scrivere i tuoi commenti per aiutarti a continuare con la seconda parte.
1. Alcune note sull'architettura SDSS
1.1. MetaTrader 5 su un server
Questo è un terminale MetaTrader 5 in esecuzione su una macchina disponibile 24 ore al giorno. Questo computer può essere un server privato virtuale (VPS) o un server dedicato (DS). MetaTrader 5 su un server comunica con l’applicazione Twitter tramite un servizio web RESTful Il formato per lo scambio di dati è JSON. Nella seconda parte di questo articolo implementeremo il livello MQL5 che consuma il servizio Web, secondo il protocollo di comunicazione che definiremo più avanti in questo testo.
1.2. Applicazione Twitter
Come abbiamo detto nell'introduzione, stiamo sviluppando l'app Twitter dell'SDSS nella prima parte di questo articolo. Questa è un'applicazione web PHP che fondamentalmente riceve segnali dal terminale MetaTrader 5, li memorizza in un database MySQL e poi li twitta. Tuttavia, questa app può essere estesa per gestire molti problemi che richiedono capacità umane per essere risolti.
Ad esempio, vorrai acquisire conoscenza e creare un'ontologia web ontology con i segnali ricevuti da "MetaTrader 5 su un server", filtrati da persone, per vedere quanto è affidabile il tuo EA dal punto di vista umano. Potremmo calcolare l'affidabilità di un dato segnale (un tweet) dai retweet e dai preferiti ad esso associati. Questa è solo un'idea, teoricamente possibile, che però non può essere trattata in questo articolo. È solo un'applicazione pratica basata sul paradigma del calcolo basato sull'uomo (HBC).
1.3. Twitter
Secondo Wikipedia, Twitter è il famoso social network e microblog il cui servizio consente agli utenti di inviare e leggere brevi messaggi di testo di 140 caratteri, chiamati tweet.
2. Specifiche del servizio Web RESTful
2.1. Panoramica di REST
REST, SOAP and XML-RPC sono i tre modelli architetturali più utilizzati per la creazione di un servizio web. Poiché la maggior parte delle moderne applicazioni Web 2.0 utilizza questo modello per sviluppare i propri servizi, codificheremo anche i nostri SDSS su REST. Ti incoraggio ad approfondire questo argomento leggendo il documento intitolato L'API REST di Twitter. In breve, REST è uno scambio di chiamate HTTP con JSON o XML come formato di scambio dati.
A differenza di SOAP e XML-RPC, REST è molto facile da implementare ed è anche il più veloce. È il più semplice perché non esiste una specifica di protocollo nello stesso senso in cui esiste in XML-RPC e SOAP. Ciò significa che lo sviluppatore non deve apprendere alcun pseudo-linguaggio XML per distribuire il servizio web. D'altra parte, REST può utilizzare JSON come formato di scambio dati tra il client e il server, il che consente di dare una risposta più rapida. In effetti, qualsiasi oggetto rappresentato in JSON occupa sempre meno byte rispetto alla sua stessa rappresentazione in XML. Questo perché JSON è più semantico o, in altre parole, JSON ha meno elementi sintattici di XML per rappresentare le informazioni.
2.2. Riferimento API SDSS
Hai già letto il documento intitolato The Twitter REST API? Ora, con tutto ciò che è stato detto, le specifiche API di Twitter possono servire a prendere alcune idee e applicarle nella creazione della nostra API SDSS. Ricorda che stiamo rendendo le cose molto semplici perché l'obiettivo di questo articolo non è sviluppare completamente l'SDSS, che potrebbe essere implementato da una startup tecnologica, ma mostrarne l'applicazione pratica nella vita reale in cui puoi connettere il tuo terminale MetaTrader 5 con un servizio web esterno. Di conseguenza, in questa sezione stiamo progettando un'API estremamente semplice con un unico metodo REST che utilizza il verbo HTTP POST. Questo serve per ricevere, archiviare nel database e twittare un determinato segnale di trading di EA.
2.2.1. Generale
L'API dovrebbe essere ospitata su http://api.sdss-your-startup.com e dovrebbe essere accessibile tramite HTTP o HTTPS. Per le richieste POST, i parametri vengono inviati nel corpo del POST in formato JSON.
2.2.2. Risorse REST
| Risorsa | URL | Descrizione |
|---|---|---|
| POST segnale/aggiungi | http://api.sdss-your-startup.com/signal/add | Invia un segnale EA all'applicazione Twitter. Questa è la richiesta che viene eseguita dal terminale MetaTrader 5 affinché SDSS memorizzi e twitti il segnale di trading. |
Come indicato nell'introduzione, questo articolo è social, quindi ti incoraggio a elencare qui i metodi REST che vorresti implementare nel tuo Social Decision Support System. Sentiti libero di lasciare i tuoi commenti e condividere con la comunità MQL5.
2.2.3. POST segnale/aggiungi
| Parametro | Descrizione |
|---|---|
| ea_id | L'ID dell'EA che sta inviando il nuovo segnale. Valore di esempio: 12345 |
| symbol | Il simbolo coinvolto in questa transazione. Valore di esempio: EURUSD |
| operazione | L'operazione da eseguire. Valore di esempio: COMPRA o VENDI |
| valore | Il valore del simbolo al momento della transazione. Valore di esempio: 1.3214 |
Esempio di richiesta:
{
"ea_id": 1,
"symbol": "AUDUSD",
"operation": "BUY",
"value": 0.9281
}
Con questo esempio sotto mano, ci sono due cose importanti da notare. Da un lato, supponiamo per il momento che ci sia un solo terminale MetaTrader 5 che invia segnali all'applicazione Twitter. Per questo motivo non è necessario l'ID terminale. Se poi, in seguito, decidiamo di estendere il sistema e sviluppare ulteriormente la nostra startup, probabilmente vorremo collegare più terminali con l'app Twitter.
Quindi, in tal caso, aggiungeremmo un campo denominato mt5_id per identificare il terminale MetaTrader 5. D'altra parte, nota che la chiamata sopra dovrebbe essere protetta da un meccanismo di autenticazione (Autenticazione HTTP di base su SSL, autenticazione basata su token o OAuth). Tuttavia, stiamo saltando questa parte, ma non dimenticare di evidenziare questo problema. Si prega di notare che senza un meccanismo di autenticazione tra il terminale MetaTrader 5 e l'app Twitter, chiunque conosca il protocollo di comunicazione potrebbe inviare segnali di trading all'app Twitter nella Figura 1. Architettura SDSS.
3. La progettazione del database dell'app Web
La specifica dell'API REST ci ha aiutato a vedere come funziona il sistema, quindi ora possiamo capire il design del database:
# MySQL database creation...
CREATE DATABASE IF NOT EXISTS sdss;
use sdss;
# Please, change the user's password in production
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, LOCK TABLES,
CREATE TEMPORARY TABLES ON `sdss`.* TO 'laplacianlab'@'localhost' IDENTIFIED BY 'password';
CREATE TABLE IF NOT EXISTS eas (
id mediumint UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(32),
description TEXT,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (id)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS signals (
id int UNSIGNED NOT NULL AUTO_INCREMENT,
id_ea mediumint UNSIGNED NOT NULL,
symbol VARCHAR(10) NOT NULL,
operation VARCHAR(6) NOT NULL,
value DECIMAL(9,5) NOT NULL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (id),
FOREIGN KEY (id_ea) REFERENCES eas(id)
) ENGINE=InnoDB;
# Dump some sample data...
INSERT INTO eas(name, description) VALUES
('Bollinger Bands', '<p>Robot based on Bollinger Bands. Works with H4 charts.</p>'),
('Two EMA', '<p>Robot based on the crossing of two MA. Works with H4 charts.</p>'); 4. Programmazione del servizio Web PHP RESTful
Nelle parole dei suoi stessi sviluppatori, Slim è un micro framework PHP che ti aiuta a scrivere rapidamente applicazioni Web e API semplici ma potenti. Sì, hai indovinato! Scriveremo la nostra API RESTful su Slim, con pochissime righe di codice. Ricorda che stiamo codificando un solo metodo HTTP POST per motivi didattici e di semplicità. Per favore, leggi la documentazione ufficiale di Slim per sapere in dettaglio come funziona.
Figure 2. Struttura di directory dell'API PHP basata su Slim
config\config.php
<?php // Creating constants. // General define('BASE_URL', 'laplacianlab.local'); define('APPLICATION_PATH', realpath(dirname(__FILE__)) . '/../'); // Database connection define('DB_NAME', 'sdss'); define('DB_USER', 'laplacianlab'); define('DB_PASSWORD', 'password'); // Don't forget to change this in your production server! define('DB_SERVER', 'localhost');
model\DBConnection.php
<?php class DBConnection { private static $instance; private $mysqli; private function __construct() { $this->mysqli = new MySQLI(DB_SERVER, DB_USER, DB_PASSWORD, DB_NAME); } public static function getInstance() { if (!self::$instance instanceof self) self::$instance = new self; return self::$instance; } public function getHandler() { return $this->mysqli; } }
public\.htaccess
<IfModule mod_rewrite.c>
<IfModule mod_negotiation.c>
Options -MultiViews
</IfModule>
RewriteEngine On
# Redirect Trailing Slashes...
RewriteRule ^(.*)/$ /$1 [L,R=301]
# Handle Front Controller...
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [L]
</IfModule>public\index.php
<?php // Bootstrap logic require_once '../config/config.php'; set_include_path(get_include_path() . PATH_SEPARATOR . APPLICATION_PATH . '/vendor/'); set_include_path(get_include_path() . PATH_SEPARATOR . APPLICATION_PATH . '/model/'); require_once 'slim/slim/Slim/Slim.php'; require_once 'DBConnection.php'; use \Slim\Slim; Slim::registerAutoloader(); $app = new Slim(); $app->response->headers->set('Content-Type', 'application/json'); // RESTful API methods // POST signal/add $app->post('/signal/add', function() { $request = Slim::getInstance()->request(); $signal = json_decode($request->getBody()); $sql = 'INSERT INTO signals(id_ea, symbol, operation, value) VALUES (' . mysql_real_escape_string($signal->ea_id) . ",'" . mysql_real_escape_string($signal->symbol) . "','" . mysql_real_escape_string($signal->operation) . "'," . mysql_real_escape_string($signal->value) . ')'; DBConnection::getInstance()->getHandler()->query($sql); $signal->id = DBConnection::getInstance()->getHandler()->insert_id; echo json_encode($signal); }); // More API methods here!.., according to your API spec $app->run();
composer.json
{
"require": {
"slim/slim": "2.*",
"abraham/twitteroauth": "dev-master"
}
} Con quanto sopra possiamo testare il servizio web nella nostra macchina di sviluppo locale. A proposito, non dimenticare (1) di aggiungere una nuova voce nel tuo file hosts in modo che Windows possa risolvere il nome di dominio locale api.laplacianlab.local e (2) creare un nuovo host virtuale per il tuo Apache.
C:\Windows\System32\Drivers\etc\hosts
::1 localhost # Copyright (c) 1993-2009 Microsoft Corp. # # This is a sample HOSTS file used by Microsoft TCP/IP for Windows. # # This file contains the mappings of IP addresses to host names. Each # entry should be kept on an individual line. The IP address should # be placed in the first column followed by the corresponding host name. # The IP address and the host name should be separated by at least one # space. # # Additionally, comments (such as these) may be inserted on individual # lines or following the machine name denoted by a '#' symbol. # # For example: # # 102.54.94.97 rhino.acme.com # source server # 38.25.63.10 x.acme.com # x client host # localhost name resolution is handled within DNS itself. # 127.0.0.1 localhost # ::1 localhost 127.0.0.1 localhost 127.0.0.1 api.laplacianlab.local
httpd-vhosts.conf
# Virtual Hosts # # Required modules: mod_log_config # If you want to maintain multiple domains/hostnames on your # machine you can setup VirtualHost containers for them. Most configurations # use only name-based virtual hosts so the server doesn't need to worry about # IP addresses. This is indicated by the asterisks in the directives below. # # Please see the documentation at # <URL:http://httpd.apache.org/docs/2.4/vhosts/> # for further details before you try to setup virtual hosts. # # You may use the command line option '-S' to verify your virtual host # configuration. # # VirtualHost example: # Almost any Apache directive may go into a VirtualHost container. # The first VirtualHost section is used for all requests that do not # match a ServerName or ServerAlias in any <VirtualHost> block. # <VirtualHost *:80> ServerAdmin webmaster@laplacianlab.local DocumentRoot "c:/wamp/www/laplacianlab/public" ServerName api.laplacianlab.local ErrorLog "logs/api.laplacianlab.local-error.log" CustomLog "logs/api.laplacianlab.local-access.log" common <directory "c:/wamp/www/laplacianlab/public"> Options FollowSymLinks AllowOverride all Order Deny,Allow Deny from all Allow from 127.0.0.1 </directory> </VirtualHost>Ora stiamo testando la nostra prima risorsa REST con RESTClient, che è un complemento di Firefox per il debug dei servizi web RESTful. Se tutto va per il meglio, il servizio Web dovrà eseguire la logica che abbiamo codificato nel metodo Slim e inviare un risultato HTTP 200 insieme a una risposta JSON.
Figure 3. Invio di un segnale POST/richiesta di aggiunta a http://api.laplacianlab.local
L'intestazione della risposta HTTP per il segnale POST/richiesta di aggiunta sopra è la seguente:
Status Code: 200 OK Connection: Keep-Alive Content-Length: 70 Content-Type: application/json Date: Mon, 07 Apr 2014 18:12:34 GMT Keep-Alive: timeout=5, max=100 Server: Apache/2.4.4 (Win64) PHP/5.4.12 X-Powered-By: PHP/5.4.12
E questo è il corpo della risposta HTTP:
{
"ea_id": 1,
"symbol": "AUDUSD",
"operation": "BUY",
"value": 0.9281,
"id": 22
} Abbiamo capito! Abbiamo appena implementato la parte del nostro Sistema di supporto alle decisioni sociali che corrisponde alla figura seguente. Ma ricorda!, dovrebbe esserci un livello di autenticazione per proteggere tali chiamate in uno scenario reale.
Figure 4. MetaTrader 5 e l'app Twitter parlano tra loro tramite un servizio web RESTful
5. Integrazione dell'app Web con Twitter
Ora ci occupiamo di quella parte del diagramma di rete che invia a Twitter i segnali di trading dall'app Slim PHP Twitter.
Figura 5. Tweet di segnali di trading dall'app Twitter a Twitter
A questo punto, cosa facciamo? Ancora una volta, hai indovinato! Prima di tutto hai bisogno dell'applicazione Twitter. Quindi vai su Twitter Developers, accedi con il tuo account Twitter (devi prima avere un account Twitter in modo da poter creare un'app Twitter), vai su "Le mie applicazioni" e fai clic su "Crea nuova app".
Figura 6. Crea una nuova app in Twitter Developers
Devi inserire i dettagli della tua nuova app e accettare le ‘Regole della strada’ per gli sviluppatori. Ad esempio, i dettagli della mia nuova applicazione sono i seguenti:
Nome: SDSS di Laplacianlab
Descrizione: Sistema di supporto alle decisioni sociali
Website: http://api.laplacianlab.local
Callback URL: http://api.laplacianlab.local/twitter/oauth_callback
Ora vai alla scheda denominata "Autorizzazioni" e aggiorna le autorizzazioni a "Lettura e scrittura". Infine, dopo aver creato la tua applicazione Twitter, annota la tua chiave API, il tuo segreto API e il tuo Oauth callback in modo che tu possa usarli come costanti nel tuo file config\config.php:
// Twitter OAuth define('API_KEY', 'akMnfXR45MkoaWbZoPiu3'); define('API_SECRET', '45Mkoa54NcvQRBbf119qWerty0DnIW45MncvFgqw'); define('OAUTH_CALLBACK', 'http://api.laplacianlab.local/twitter/oauth_callback');
A questo punto stiamo mettendo in comunicazione la micro web app Slim PHP con SDSS di Laplacianlab (l'app Twitter che abbiamo creato sopra). Per fare ciò è necessario conoscere le basi del protocollo il protocollo OAuth 2.0 quindi, vi consigliamo di leggere la documentazione ufficiale su questo argomento. Dovresti avere familiarità con il diagramma di flusso OAuth.
Figura 7. Diagramma di flusso OAuth
Quindi, secondo questo diagramma, dobbiamo ora creare la seguente tabella MySQL per memorizzare i proprietari delle risorse (gli utenti di twitter che vogliono twittare i segnali di trading):
CREATE TABLE IF NOT EXISTS twitterers ( id mediumint UNSIGNED NOT NULL AUTO_INCREMENT, twitter_id VARCHAR(255), access_token TEXT, access_token_secret TEXT, created_at DATETIME DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (id) ) ENGINE=InnoDB;
In particolare, stiamo utilizzando TwitterOAuth, che è una libreria PHP per lavorare con l'API OAuth di Twitter. Se hai installato Slim tramite Composer utilizzando il file composer.json che ho allegato nella sezione precedente, non devi preoccuparti di installare questa libreria perché TwitterOAuth sarà già copiato nella cartella del fornitore della tua app PHP.
Altrimenti, puoi sempre scaricare questo componente PHP da GitHub. Con il flusso OAuth in vista, dobbiamo solo programmare il metodo per gli utenti di twitter che consentirà loro di applicare le autorizzazioni a SDSS di Laplacianlab e al callback di oauth. Per ora il nostro SDSS è così semplice che possiamo scrivere tutto nel file index.php.
public\index.php
<?php // Bootstrap logic require_once '../config/config.php'; set_include_path(get_include_path() . PATH_SEPARATOR . APPLICATION_PATH . '/vendor/'); set_include_path(get_include_path() . PATH_SEPARATOR . APPLICATION_PATH . '/model/'); require_once 'slim/slim/Slim/Slim.php'; require_once 'abraham/twitteroauth/twitteroauth/twitteroauth.php'; require_once 'DBConnection.php'; use \Slim\Slim; session_start(); Slim::registerAutoloader(); $app = new Slim(); $app->response->headers->set('Content-Type', 'application/json'); // RESTful API methods // POST signal/add $app->post('/signal/add', function() { $request = Slim::getInstance()->request(); $signal = json_decode($request->getBody()); $sql = 'INSERT INTO signals(id_ea, symbol, operation, value) VALUES (' . mysql_real_escape_string($signal->ea_id) . ",'" . mysql_real_escape_string($signal->symbol) . "','" . mysql_real_escape_string($signal->operation) . "'," . mysql_real_escape_string($signal->value) . ')'; DBConnection::getInstance()->getHandler()->query($sql); $signal->id = DBConnection::getInstance()->getHandler()->insert_id; echo json_encode($signal); }); // More API methods here!.., according to your API spec // Twitter OAuth flow // This method is for users to give permissions to Laplacianlab's SDSS to tweet // on their behalf. $app->get('/tweet-signals', function() use ($app) { if (empty($_SESSION['twitter']['access_token']) || empty($_SESSION['twitter']['access_token_secret'])) { $connection = new TwitterOAuth(API_KEY, API_SECRET); $request_token = $connection->getRequestToken(OAUTH_CALLBACK); if ($request_token) { $_SESSION['twitter'] = array( 'request_token' => $request_token['oauth_token'], 'request_token_secret' => $request_token['oauth_token_secret'] ); switch ($connection->http_code) { case 200: $url = $connection->getAuthorizeURL($request_token['oauth_token']); // redirect to Twitter $app->redirect($url); break; default: echo '{"error":{"text":"Connection with Twitter failed"}}'; break; } } else { echo '{"error":{"text":"Error Receiving Request Token"}}'; } } else { echo '{"message":{"text":"Everything is ok! Laplacianlab\'s SDSS ' . 'can now tweet trading signals on your behalf. Please, if you no ' . 'longer want the SDSS to tweet on your behalf, log in your Twitter ' . 'account and revoke access."}}'; } }); // This is the OAuth callback $app->get('/twitter/oauth_callback', function() use ($app) { if(isset($_GET['oauth_token'])) { $connection = new TwitterOAuth( API_KEY, API_SECRET, $_SESSION['twitter']['request_token'], $_SESSION['twitter']['request_token_secret']); $access_token = $connection->getAccessToken($_REQUEST['oauth_verifier']); if($access_token) { $connection = new TwitterOAuth( API_KEY, API_SECRET, $access_token['oauth_token'], $access_token['oauth_token_secret']); // Set Twitter API version to 1.1. $connection->host = "https://api.twitter.com/1.1/"; $params = array('include_entities' => 'false'); $content = $connection->get('account/verify_credentials', $params); if($content && isset($content->screen_name) && isset($content->name)) { $_SESSION['twitter'] = array( 'id' => $content->id, 'access_token' => $access_token['oauth_token'], 'access_token_secret' => $access_token['oauth_token_secret'] ); // remove the request token from session unset($_SESSION['twitter']['request_token']); unset($_SESSION['twitter']['request_token_secret']); // Twitter's OAuth access tokens are permanent until revoked so // we try to update them when a tweeterer tries to give access // permissions again $sql = "SELECT * FROM twitterers WHERE twitter_id='$content->id'"; $result = DBConnection::getInstance()->getHandler()->query($sql); if($result->num_rows) { $sql = "UPDATE twitterers SET " . "access_token = '" . mysql_real_escape_string($access_token['oauth_token']) . "', " . "access_token_secret = '" . mysql_real_escape_string($access_token['oauth_token_secret']) . "' " . "WHERE twitter_id ='" . $content->id . "'"; } else { $sql = "INSERT INTO twitterers(twitter_id, access_token, access_token_secret) " . "VALUES ('" . mysql_real_escape_string($content->id) . "','" . mysql_real_escape_string($access_token['oauth_token']) . "','" . mysql_real_escape_string($access_token['oauth_token_secret']) . "')"; } DBConnection::getInstance()->getHandler()->query($sql); echo '{"message":{"text":"Everything is ok! Laplacianlab\'s SDSS ' . 'can now tweet trading signals on your behalf. Please, if you no ' . 'longer want the SDSS to tweet on your behalf, log in your Twitter ' . 'account and revoke access."}}'; } else { echo '{"error":{"text":"Login error"}}'; } } } else { echo '{"error":{"text":"Login error"}}'; } }); $app->run();
La cosa più importante da fare qui è memorizzare nel database i due dati che consentono all'SDSS di effettuare chiamate autenticate a Twitter per conto degli utenti che hanno fornito i permessi di accesso. Questi due dati sono il token di accesso e il segreto del token di accesso, che sono permanenti fino alla revoca da parte degli utenti. Pertanto, il Social Decision Support System non memorizza mai le credenziali dell'utente e comunque gli utenti possono rimuovere le proprie autorizzazioni di accesso ogni volta che lo desiderano tramite revoca.
Sebbene l'SDSS basato su PHP disponga del token di accesso corretto e del segreto del token di accesso, esso può eseguire chiamate a Twitter come le seguenti:
// Let's assume there's an object named $user to access the tokens... $connection = new TwitterOAuth( API_KEY, API_SECRET, $user->getAccessToken(), $user->getAccessTokenSecret()); $message = "Hello world! I am Laplacianlab's SDSS and I am tweeting on behalf of a tweeterer."; $connection->post('statuses/update', array('status' => $message));
Abbiamo tutti gli elementi necessari. Ora è molto facile completare la risorsa POST signal/add dell'API SDSS che abbiamo iniziato a codificare in 4. La programmazione del servizio Web PHP RESTful, quindi è lasciata come esercizio, nel quale si dovrà aggiungere il codice PHP necessario per twittare alcuni dati di prova.
Conclusione
Questo articolo ha mostrato come connettere un terminale MetaTrader 5 con Twitter per poter twittare i segnali di trading dei tuoi EA. Abbiamo sviluppato un sistema assistito da computer che combina la potenza di elaborazione dei robot con le capacità cognitive degli individui. Vogliamo che le persone convalidino i segnali di trading robotici che altrimenti verrebbero automaticamente immessi sul mercato dagli Expert Advisor. In questo modo abbiamo aperto le porte a un argomento nuovo ed entusiasmante, ovvero l’acquisizione di conoscenze sui sistemi di trading automatico quando le persone retweettano o mettono in preferito i segnali di trading. Questa è un'applicazione pratica basata sul paradigma del calcolo basato sull'uomo (HBC).
L'implementazione di un sistema completo di supporto alle decisioni sociali richiede tempo, quindi questo esercizio può essere visto come un'idea per la creazione di una startup tecnologica. Abbiamo iniziato a sviluppare un SDSS che si compone di tre parti principali:
- Terminale MetaTrader 5 in esecuzione su un VPS o un DS;
- Applicazione web PHP Twitter basata su Slim;
- Twitter;
Nello specifico, in questa prima parte abbiamo implementato l'architettura del servizio web RESTful che comunica MetaTrader 5 con la web app Slim PHP, e abbiamo anche collegato la web app PHP con Twitter tramite il protocollo OAuth. Nella parte successiva codificheremo un framework MQL5-RESTful allo stesso modo come spiegato nell'articolo MQL5-RPC. Chiamate di procedura remota da MQL5: Accesso al servizio Web e analizzatore ATC XML-RPC per divertimento e profitto.
Tradotto dall’inglese da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/en/articles/925
Come accedere al database MySQL da MQL5 (MQL4)
Racconti di robot di trading: Meno è veramente di più?
MQL5 Wizard (Procedura guidata): Effettuare ordini, stop-loss e Take Profit su prezzi calcolati. Estensione libreria standard
Indicatore per la costruzione di un grafico Three Line Break
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso