Construindo uma Startup em Tecnologia Social, Parte I: Tuíte seus Sinais do MetaTrader 5

Introdução

Este artigo tem como objetivo ilustrar, através de um exemplo prático, como você pode comunicar um terminal MetaTrader 5 com um serviço web externo. Estaremos tuitando os sinais de negociação gerados por um Expert Advisor.

Essa idéia vem de um conceito específico da negociação automatizada chamada de negociação assistida por computador. Em suma, os computadores do século XXI não possuem habilidades cognitivas, mas eles são muito bons no processamento de informações e na execução de dados. Então, por que não construímos sistemas computacionais utilizando os cérebros humanos como filtros de tomadas de decisões? Esta abordagem é inspirada no paradigma da Computação Humana (HBC ou Human-based Computation), portanto, centra-se no desenvolvimento de ferramentas de apoio à decisão, em vez da codificação de algoritmos para tomadas de decisões.

Eu tinha pensado inicialmente em criar um feed RSS com os sinais de negociação gerados pelos meus EAs (presume-se que exista um sistema de negociação de médio ou a longo prazo, essa idéia não é válida para sistemas automáticos de escalpelamento). Uma pessoa com acesso ao feed deve validar meus sinais robóticos de acordo com as circunstâncias do momento, pouco antes de colocá-los ao mercado. No entanto, logo percebi que tudo poderia ser ainda mais sociável, e pensei comigo mesmo: 'Por que não publicar meus sinais de negociação no Twitter? Isso me levou a desenvolver este Sistema de Apoio à Decisões Sociais ou SDSS (em inglês).

Figura 1. Arquitetura SDSS

A propósito, se você pretende criar uma startup de tecnologia relacionada à negociação FX, este artigo poderá ajudá-lo a tirar algumas idéias. Ele pode ser visto como um guia técnico para a construção de um SaaS comercial (Software as a Service) baseado em um SDSS.

Este texto é longo, então eu decidi dividi-lo em duas partes. A primeiro foca-se na arquitetura dos serviços web, o protocolo de comunicação utilizado entre o terminal MetaTrader 5 e o aplicativo do Twitter e, finalmente, a integração do aplicativo web com o Twitter. A segunda parte irá cobrir o diagrama da camada de rede MQL5, que foi mostrado acima e que se destina a consumir nosso serviço web RESTful do Sistema de Apoio à Decisões Sociais. Especificamente, iremos codificar uma estrutura em MQL5-RESTful da mesma maneira como foi explicado no artigo MQL5-RPC. Chamadas de procedimento remoto de MQL5: Acesso de serviço da Web e analisador XML-RPC ATC para diversão e lucro.

Este artigo também é social, assim, eu encorajo-os a deixarem seus comentários para ajudar com a continuação da segunda parte.

1. Algumas observações sobre a Arquitetura SDSS

1.1. MetaTrader 5 em um servidor

Este é um terminal MetaTrader 5 rodando em uma máquina que está disponível 24 horas por dia. Este computador pode ser um Servidor Virtual Privado (VPS) ou um servidor dedicado (DS). O MetaTrader 5 em um servidor se comunica com o aplicativo do Twitter através do serviço web RESTful. O formato de transferência de dados é em JSON. Na segunda parte deste artigo, vamos implementar a camada MQL5 para trabalhar com o serviço web, de acordo com o protocolo de comunicação que definiremos mais adiante neste artigo.

1.2. Aplicativo Twitter

Como dissemos na introdução, na primeira parte deste artigo nós estaremos desenvolvendo um aplicativo SDSS para o Twitter. Esta é uma aplicação web em PHP que basicamente recebe sinais do terminal MetaTrader 5, armazena-os em um banco de dados MySQL e, em seguida, tuíta eles. No entanto, este aplicativo pode ser estendido, a fim de lidar com muitos problemas que exigem da capacidade humana para serem resolvidos.

Por exemplo, para avaliar a confiabilidade de um EA a partir do ponto de vista de uma pessoa, você iria gostar de coletar informações e construir uma ontologia web com os sinais recebidos do 'MetaTrader 5 em um servidor ". Podemos calcular a confiabilidade de um dado sinal (um tweet) dos retweets e dos favoritos associados a ele. Esta é apenas uma idéia que não pode ser abordada neste artigo, é claro, mas é possível teoricamente. Ela é apenas uma aplicação prática baseada no paradigma da Computação Humana (HBC).

1.3. Twitter

Como a Wikipedia diz: O Twitter é uma famosa rede social online e um serviço de micro blog que permite aos usuários enviar e ler mensagens de texto curtas de até 140 caracteres, chamadas de tweets.

2. Especificação do Serviço Web RESTful

2.1. Visão geral do REST

REST, SOAP e XML-RPC são os três padrões arquitetônicos mais utilizados para a construção de um serviço web. Como a maioria das modernas aplicações Web 2.0 usa esse padrão para desenvolver os seus serviços, nós também iremos programar nosso SDSS em REST. Eu convido você a aprender mais sobre esse assunto lendo o documento intitulado The Twitter API REST. Em suma, o REST é uma troca de chamadas HTTP com JSON ou XML como um formato de intercâmbio de dados.

Ao contrário de SOAP e XML-RPC, REST é muito fácil de ser implementado sendo também o mais rápido. Ele é o mais simples, pois não há especificação de protocolo da mesma maneira que há em XML-RPC e SOAP. Isso significa que o desenvolvedor não precisa aprender qualquer pseudo-linguagem em XML, a fim de implantar o serviço web. Por outro lado, o REST pode usar JSON como formato de troca de dados entre o cliente e o servidor, o que permite dar uma resposta mais rápida. Na verdade, qualquer objeto representado em JSON sempre ocupa menos bytes do que em XML. Isto é porque o JSON é mais semântico, ou dizendo de outra forma, JSON tem elementos menos sintáticos do que XML na representação das informações.

2.2. Referência API SDSS

Você já leu o documento intitulado The Twitter API REST? Agora, com tudo o que foi dito, a especificação API do Twitter pode servir para ter algumas ideias e aplicá-las na construção de nosso API SDSS. Lembre-se que estaremos fazendo coisas bem simples, pois o objetivo deste artigo não é de desenvolver completamente o SDSS, o que poderia ser implementado por uma startup em tecnologia, mas mostrar uma aplicação prática na vida real, onde é possível conectar seu terminal MetaTrader 5 com um serviço web externo. Assim, nesta seção estaremos projetando um API extremamente simples com um único método REST que utiliza o método POST em HTTP. Isto é para receber, armazenar no banco de dados, e tuitar o sinal de negociação de um determinado EA.

2.2.1. Geral

O API deve ser hospedado em http://api.sdss-your-startup.com, e deve ser acessado via HTTP ou HTTPS. Para solicitações POST, os parâmetros são apresentados no corpo POST em formato JSON.

2.2.2. Recursos em REST

Recursos	URL	Descrição
POST signal/add	http://api.sdss-your-startup.com /signal/add	Envia um sinal do EA para o aplicativo Twitter. Este é o pedido, que é executado pelo terminal MetaTrader 5 para que o SDSS armazene e tuíte o sinal de negociação.

Como indicado na introdução deste artigo social, eu encorajo-vos aqui a listar os métodos REST que você gostaria de implementar em seu Sistema de Apoio à Decisão social (SDSS). Sinta-se livre para fazer seus comentários e compartilhar com a comunidade MQL5.

2.2.3. POST signal/add

Parâmetro	Descrição
ea_id	O ID do EA que está enviando o novo sinal. Valor Exemplo: 12345
symbol	O símbolo envolvido nesta transação. Valor Exemplo: EURUSD
operation	A operação a ser executada. Valor Exemplo: BUY ou SELL
value	O valor do símbolo no momento da operação. Valor Exemplo: 1,3214

Exemplo do pedido:

{
    "ea_id": 1,
    "symbol": "AUDUSD",
    "operation": "BUY",
    "value": 0.9281    
}

Tendo em vista este exemplo, há duas coisas importantes a serem observadas. Por um lado, vamos supor por um momento que só há um terminal MetaTrader 5 de envio de sinais para o aplicativo Twitter. Por esta razão, não há necessidade da identificação do terminal. Se, em seguida, mais tarde, decidirmos estender o sistema e desenvolver mais o nosso startup, provavelmente, nós vamos querer conectar vários terminais com o aplicativo Twitter.

Então, nesse caso, nós adicionaremos um campo chamado mt5_id a fim de identificar o terminal MetaTrader 5. Por outro lado, note que a chamada acima deve ser garantida por um mecanismo de autenticação (Autenticação HTTP sobre SSL, autenticação baseada em tokens ou OAuth). No entanto, pularemos esta parte, mas não se esqueça de apontar para essa questão. Por favor, note que, sem um mecanismo de autenticação entre o terminal MetaTrader 5 e o aplicativo do Twitter, quem conhecer o protocolo de comunicação poderia enviar sinais de negociação para o aplicativo do Twitter na Figura 1. Arquitetura SDSS.

3. Projeto do Banco de Dados do Aplicativo Web

A especificação API REST ajudou-nos a ver como o sistema funciona, portanto, podemos agora compreender o projeto de banco de dados:

# 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. Programando o serviço Web RESTful em PHP

Nas palavras de seus próprios desenvolvedores, Slim é uma micro estrutura em PHP que ajuda você a escrever rapidamente simples, porém poderosas aplicações web e APIs. Sim, você adivinhou! Vamos escrever nossa API RESTful em Slim, com poucas linhas de código. Lembre-se que estamos apenas programando um método POST em HTTP por razões de aprendizagem e simplicidade. Por favor, leia a documentação oficial do Slim para saber em detalhes como ele funciona.

Figura 2. Estrutura de diretórios do API PHP baseado em 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"
    }
}

Com tudo isso, podemos testar o serviço web em nossa máquina de desenvolvimento local. A propósito, (1) não se esqueça de adicionar uma nova entrada no seu arquivo hosts para que o seu Windows possa resolver o domínio local de nome api.laplacianlab.local, e (2) crie um novo host virtual para o seu 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 [e-mail]
        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>

Agora estaremos testando nosso primeiro recurso REST com o RESTClient (Cliente REST), que é um complemento do Firefox para a depuração de serviços Web RESTful. Se tudo correr bem, o serviço web deve executar a lógica que nós codificamos no método Slim acima e nos enviar um resultado HTTP 200 juntamente com uma resposta em JSON.

Figura 3. Enviando um pedido POST signal/add para http://api.laplacianlab.local

O cabeçalho de resposta HTTP para o pedido executado acima POST signal/add é a seguinte:

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 este é o corpo da resposta em HTTP:

{
        "ea_id": 1,
        "symbol": "AUDUSD",
        "operation": "BUY",
        "value": 0.9281,
        "id": 22
}

Nós conseguimos! Acabamos de implementar a parte do nosso Sistema de Apoio à Decisão Social, que corresponde à figura abaixo. Mas lembre-se!, em um cenário real, deve haver uma camada de autenticação para proteger tais chamadas.

Figura 4. Comunicação entre o MetaTrader 5 e o aplicativo Twitter através do serviço web REST

5. Integração do aplicativo Web com o Twitter

Agora vamos lidar com essa parte do diagrama de rede que tuita os sinais de negociação do aplicativo Twitter em PHP Slim para o Twitrer.

Figura 5. Tuitando sinais de negociação do aplicativo Twitter para o Twitter

O que vem em seguida? Mais uma vez, você adivinhou! Primeiramente você precisa de um aplicativo Twitter. Então, por favor, vá ao Twitter Developers, entre com a sua conta Twitter (você primeiro precisa ter uma conta no Twitter para que você possa criar um aplicativo do Twitter), vá em "Meus Aplicativos" e clique em "Create New App".

Figura 6. Criando um novo aplicativo no Twitter Developers

Você tem que preencher os detalhes do seu novo aplicativo e aceitar as regras (Developer Rules of the Road). Por exemplo, os detalhes da minha nova aplicação são os seguintes:

Nome: Laplacianlab's SDSS

Descrição: Social Decision Support System

Website: http://api.laplacianlab.local

URL de retorno de chamada: http://api.laplacianlab.local/twitter/oauth_callback

Por favor, agora vá para a aba chamada "Permissions" e atualize as permissões para "Read and Write". Finalmente, após a criação do aplicativo Twitter, anote a chave do API, o seu segredo API e sua chamada de retorno Oauth em ordem para que você possa usá-los como constantes em seu arquivo config\config.php:

// Twitter OAuth

define('API_KEY', 'akMnfXR45MkoaWbZoPiu3');
define('API_SECRET', '45Mkoa54NcvQRBbf119qWerty0DnIW45MncvFgqw');
define('OAUTH_CALLBACK', 'http://api.laplacianlab.local/twitter/oauth_callback');

Neste momento estamos comunicando o micro aplicativo web Slim em PHP com o SDSS do Laplacianlab (o aplicativo Twitter que criamos acima). Para fazer isso você precisa saber o básico do protocolo OAuth 2.0 então, por favor, não perca a oportunidade de ler a documentação oficial. Você deve estar familiarizado com o diagrama de fluxo OAuth.

Figura 7. Diagrama de Fluxo OAuth

Consequentemente, de acordo com este diagrama, nós devemos criar agora a seguinte tabela MySQL para armazenar os recursos proprietários (os tuiteiros que quiserem tuitar os sinais de negociação):

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;

Especificamente, estamos usando o TwitterOAuth, que é uma biblioteca em PHP para trabalhar com o API OAuth do Twitter. Se você instalou o Slim via Composer utilizando o arquivo composer.json que eu anexei na seção anterior, então você não precisa se preocupar em instalar esta biblioteca porque TwitterOAuth já serão copiados na pasta do fornecedor do seu aplicativo PHP.

Caso contrário, você sempre poderá baixar este componente em PHP no GitHub. Com o fluxo OAuth em vista, nós só temos que programar um método para os tuiteiros aplicarem permissões ao SDSS do Laplacianlab e ao retorno de chamada OAuth. Por enquanto nosso SDSS é tão simples que nós podemos escrever tudo no arquivo 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();

 

A coisa mais importante aqui é armazenar no banco de dados os dois pedaços de dados que permitem que o SDSS faça chamadas autenticadas para o Twitter em nome dos usuários que forneceram as permissões de acesso. Estas duas peças são o token de acesso e o segredo do token de acesso, que são permanentes até que seja revogado pelos usuários. Assim, o Sistema de Apoio à Decisão social nunca armazena as credenciais do usuário, e, por outro lado, os usuários podem remover suas permissões de acesso sempre que quiser através da revogação.

Enquanto o SDSS baseado em PHP tem o acesso correto ao token e ao segredo do token de acesso, ele pode executar chamadas ao Twitter como a seguir:

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

Nós temos todos os ingredientes necessários. Agora é muito fácil de concluir os recursos de POST signal/add do API SDSS que nós começamos a programar em 4. Programando os Serviço Web RESTful em PHP, assim, deixamos como exercício para você adicionar o código necessário em PHP para tuitar alguns dados de exemplo.

Conclusão

Este artigo mostrou como conectar um terminal MetaTrader 5 com o Twitter para que você tuite sinais de negociação dos seus EAs. Nós desenvolvemos um sistema computadorizado que combina o poder de processamento dos robôs com as habilidades cognitivas dos indivíduos. Queremos que as pessoas validem os sinais de negociação robóticos, que de outra forma, eles seriam colocados automaticamente no mercado pelos Expert Advisors. Assim, abrimos uma porta para um novo e excitante assunto, que é a captura de conhecimento sobre os sistemas de negociação automatizada quando as pessoas retuitam ou favoritam os sinais de negociação. Esta é uma aplicação prática baseada no paradigma da Computação Humana (HBC).

A implantação de um completo Sistema de Apoio a Decisão social é demorado, por isso este exercício pode ser visto como uma idéia para a construção de uma startup em tecnologia. Nós começamos a desenvolver um SDSS que consiste em três partes principais:

1. O terminal MetaTrader 5 rodando em um servidor VPS ou um DS;
   
2. O aplicativo web Twitter em PHP baseado em Slim;
   
3. Twitter;
   

Especificamente, nesta primeira parte implementamos a arquitetura do serviço Web RESTful que comunica o MetaTrader 5 com o aplicativo web Slim PHP, e temos também ligado a aplicativo web em PHP com o Twitter através do protocolo OAuth. Na parte seguinte nós vamos codificar uma estrutura MQL5-RESTful da mesma maneira como foi explicado no artigo MQL5-RPC. Chamadas de procedimento remoto de MQL5: Acesso de serviço da Web e analisador XML-RPC ATC para diversão e lucro.