Accès réseau

Ce guide définit comment vous pouvez créer des algorithmes capables d'accéder à Internet. Vous trouverez ci-dessous un résumé d'une minute de cette fonctionnalité de l'API.

HTTP

La nouvelle interface Http contient plusieurs méthodes qui, une fois implémentées, devraient permettre aux cBots et à d'autres types d'algorithmes d'accéder à Internet. Pour une illustration, voir ce qui suit :

• HttpResponse Http.Get(string uri). Effectue une requête GET vers l'URI spécifié dans la chaîne passée uri et renvoie un objet HttpsResponse contenant les résultats de cette requête.

La classe HttpsRequest permet d'effectuer des requêtes plus complexes, y compris des requêtes POST. Pour effectuer ces requêtes, définissez la propriété HttpsRequest.Method sur l'une des valeurs de l'enum HttpMethod telles que HttpMethod.Put ou HttpMethod.Patch.

À son tour, la propriété HttpsRequest.Uri contient l'URI vers lequel une requête est envoyée tandis que la propriété HttpsRequest.Body peut être utilisée pour définir le corps de la requête. Voir ci-dessous un exemple de la façon dont vous pouvez utiliser un objet HttpsRequest.

• HttpResponse Http.Send(HttpRequest request). Effectue une requête vers l'URI spécifié comme valeur de la propriété request.Uri de l'objet HttpsRequest passé dans cette méthode. Ensuite, renvoie un objet HttpsResponse contenant les résultats de cette requête. Le type de requête est défini comme valeur de la propriété equest.Method.

Créer des exemples de cBots

Effectuer une requête GET

Nous allons créer un cBot simple qui effectue les actions suivantes :

• Envoie une requête GET et accède à un fichier JSON via l'API à https://forexApiExample.com/v1/exchangerate (notez que cette API est entièrement fictive).
• Si la réponse GET est réussie, le cBot désérialise le corps de la réponse en un objet d'une classe personnalisée SymbolPrice (nous avons créé cette classe à des fins de démonstration).
• Place un ordre sell limit pour un symbole à un prix légèrement supérieur au prix spécifié dans l'API.

Notez que le cBot est entièrement fictif. Bien que le code se compile, il n'effectuera aucune action significative.

Voici le code de notre exemple de cBot :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTest : Robot
    {

        protected override void OnStart()
        {

            var responseToGet = Http.Get("https://forexApiExample.com/v1/exchangerate");

            if (responseToGet.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(responseToGet.Body);
                var result = PlaceLimitOrder(TradeType.Sell, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate + 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

Si ce cBot devait accéder à une API réelle, il l'aurait fait avec succès.

Effectuer une requête POST

Nous pouvons également créer un cBot plus avancé qui atteint les objectifs suivants :

• Envoie une requête POST à la même fausse API à https://anotherForexApiExample.com/commodities/v1/getaccesstoken. Ceci est fait pour obtenir un jeton d'accès pour cette API.
• Stocke le jeton du corps de la réponse dans la variable token.
• Effectue une requête GET vers la même API avec la valeur de la variable token passée comme paramètre de requête dans l'URI (https://anotherForexApiExample.com/commodities/v1/getprices).
• En utilisant la sérialisation JSON (discutée ci-dessus), place un ordre buy stop à un prix légèrement inférieur au prix reçu de l'API.

Encore une fois, notez que ce cBot n'effectuera aucune action significative une fois compilé. Il existe uniquement à des fins d'exemple.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTestTwo : Robot
    {

        protected override void OnStart()
        {
            var uriForAccessToken = new Uri("https://anotherForexApiExample.com/commodities/v1/getaccesstoken");

            var postRequest = new HttpRequest(uriForAccessToken);

            postRequest.Method = HttpMethod.Post;

            var responseToPost = Http.Send(postRequest);

            var token = responseToPost.Body;

            var response = Http.Get($"https://anotherForexApiExample.com/commodities/v1/getprices?token={token}");

            if (response.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(response.Body);

                var result = PlaceStopOrder(TradeType.Buy, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate - 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

Client WebSocket

L'API Algo permet à quiconque d'utiliser divers services et ressources web en utilisant une connexion websocket. Comparé au protocole HTTP qui est utilisé dans la fonctionnalité d'accès réseau, le protocole WebSocket est plus rapide et permet de recevoir des données en temps réel.

Utiliser le client WebSocket

L'utilisation du client WebSocket est simple :

1. Choisissez un service qui expose un point de terminaison pour une connexion websocket
2. Initialisez un objet de la classe WebSocketClientOptions et spécifiez ses paramètres pour configurer votre client.
3. Initialisez un objet de la classe WebSocketClient et passez les options précédemment créées au constructeur.
4. Utilisez la méthode Connect() pour vous connecter à la ressource choisie et envoyez des données via la méthode Send().
5. Utilisez les gestionnaires d'événements TextReceived() et BinaryReceived() pour définir ce que votre algorithme doit faire lorsque le client WebSocket reçoit de nouvelles données.

Ci-dessous, nous allons créer un cBot simple qui se connecte à un service d'actualités économiques imaginaire via websocket. Lorsqu'une nouvelle actualité est publiée à propos du symbole auquel le cBot est actuellement attaché, l'algorithme affichera une boîte de message contenant le texte de l'actualité.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class ExampleWebSocketBot : Robot
    {

        private static WebSocketClientOptions _webSocketClientOptions = new WebSocketClientOptions 
        {
            KeepAliveInterval = new TimeSpan(0, 1, 30),
            UseDefaultCredentials = true,
        };
        private WebSocketClient _webSocketClient = new WebSocketClient(_webSocketClientOptions);
        private readonly Uri _targetUri = new Uri("ws://amazingnews.com:8000");

        protected override void OnStart()
        {
            _webSocketClient.Connect(_targetUri);
            _webSocketClient.Send("Hello");
            _webSocketClient.TextReceived += NewsReceived;
        }

        protected override void OnStop()
        {
            _webSocketClient.Close(WebSocketClientCloseStatus.NormalClosure);
        }

        private void NewsReceived(WebSocketClientTextReceivedEventArgs args) 
        {
            if (args.Text.Contains(SymbolName)) 
            {
                MessageBox.Show(args.Text, "News!", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
            }
        }
    }
}

Comme vous pouvez le voir, notre code est assez compact car nous pouvons gérer l'événement WebSocketClient.TextReceived pour afficher la boîte de message. Notez que notre cBot ne demande pas activement des informations aux services. Au lieu de cela, il réagit dynamiquement aux nouvelles informations qui lui sont fournies.

Avantages de WebSocket

Parce que websocket permet de réagir aux nouvelles données du web en temps réel, il est parfait pour s'intégrer avec des services tiers qui peuvent notifier de manière autonome vos algorithmes à propos de quelque chose. Voici quelques exemples de ressources web avec lesquelles vous pouvez utiliser le client WebSocket.

• Un calendrier d'actualités économiques. Lorsqu'une nouvelle actualité est publiée, votre algorithme peut afficher une boîte de message avec les informations clés.
• Un service d'IA générative. Lorsqu'un service d'IA commence à fournir une réponse à une invite, vous pouvez afficher le résultat mot par mot plutôt que d'avoir à attendre la réponse complète.
• Un flux de prix pour tous les symboles corrélés avec celui auquel un algorithme est attaché. Lorsque les prix sont mis à jour, ils sont immédiatement et précisément affichés aux utilisateurs de l'algorithme.
• Un réseau de médias sociaux axé sur le trading. Lorsque de nouveaux messages sont publiés à propos d'un symbole particulier, un algorithme peut afficher leur contenu aux utilisateurs.

En général, les connexions websocket offrent les avantages suivants par rapport au HTTPS classique :

• Les connexions WebSocket sont plus efficaces. Toute requête HTTP doit contenir des données supplémentaires telles que des en-têtes. Avec websocket, votre connexion est établie une seule fois, après quoi il n'est pas nécessaire d'envoyer des données redondantes.
• Les connexions WebSocket offrent une concurrence améliorée. Il n'est pas nécessaire d'interrompre les opérations de l'algorithme jusqu'à ce que vous attendiez une réponse après l'envoi d'une requête HTTP. Avec websocket, vous pouvez envoyer et recevoir des données à tout moment et les gérer de manière asynchrone.

Le client WebSocket permet à tous les types d'algorithmes d'interagir dynamiquement avec des ressources web ; cette interaction est plus rapide et plus efficace par rapport à l'utilisation de HTTP. Utilisez le client WebSocket pour créer des algorithmes puissants intégrés avec des services tiers.

Accès réseau et la propriété AccessRights

En bref, l'enum AccessRights définit si les algorithmes ont accès aux données externes à cTrader, telles que le système de fichiers de votre machine locale. Vous pouvez en savoir plus dans ce tutoriel.

Définir AccessRights sur AccessRights.FullAccess permet aux algorithmes d'effectuer des opérations avancées (telles que l'extraction d'informations du registre Windows). Les utilisateurs finaux peuvent toutefois trouver risqué d'accorder un accès complet aux cBots ou aux indicateurs, car cela peut entraîner une violation de données.

Par conséquent, AccessRights.None est généralement l'option la plus judicieuse si vous souhaitez partager vos produits algorithmiques avec d'autres. Cependant, même si vous choisissez cette option, vos produits cTrader peuvent accéder librement au Web. L'ajout de la fonctionnalité d'accès réseau à l'API cTrader Algo signifie que les cBots n'ont plus besoin que la propriété AccessRights soit définie sur AccessRights.FullAccess pour fonctionner avec des ressources sur Internet.

Cela élargit considérablement les opportunités dont disposent les développeurs d'algorithmes lors du codage de produits cTrader qu'ils ont l'intention de distribuer à d'autres traders.

Résumé

En conclusion, l'accès réseau est une fonctionnalité puissante qui permet d'élargir considérablement le nombre d'opérations que vos algorithmes peuvent effectuer sans introduire de risques supplémentaires.