Wie man ein Handelsjournal mit MetaTrader und Google-Tabellen erstellt

Inhaltsverzeichnis

• Konzept
• Einführung
• Verfügbare Lösungen
• Was ist eine Google-Tabelle?
• Google-Tabellen API
• Erstellen einer neue Google-Tabelle
• Ein Google Apps-Skript erstellen
• Ausführen der Einrichtungsfunktion
• Veröffentlichen des Projekts als Webanwendung
• Wie man Daten in Google-Tabellen postet (schreibt)
• Wie man Google-Tabellen über HTTP liest und darauf zugreift
• Implementierung und Aktualisierung von Tools für unser Trading Journal mit MetaTrader
• Erstellen eines Expert Advisors, um Daten zu posten
• Abrufen der Liste der laufenden Orders und Positionen
• Senden von Auftragslistendaten an Google-Tabelle
• Einfache Analyse zu unserer Handelsliste
• Schlussfolgerung

Konzept

In der Welt des Handels ist es heute sehr wichtig, die Fehlerquote zu verringern und die Gewinnquote zu erhöhen. Jeder Händler braucht ein Handelsjournal, um die Leistung seiner Strategie zu verbessern. Diese Arbeit erfordert jedoch viel Zeit und Präzision. Stellen Sie sich vor, dass dies automatisch geschieht.

Einführung

Das Handelsjournalsystem mit Google-Tabellen ist eine unverzichtbare Ressource für Händler aller Ebenen, die eine organisierte Nachverfolgung ihrer Handelsaktivitäten ermöglicht. Das Führen eines Handelsjournal ist unerlässlich, wenn Sie als Daytrader Fortschritte machen wollen. Man kann nicht verbessern, was man nicht misst. Es ermöglicht den Nutzern eine strukturierte Herangehensweise an ihre Handelsgeschäfte und bietet Einblicke, die für die Leistungsbewertung und -verbesserung entscheidend sind. Die Zugänglichkeit und Nutzerfreundlichkeit dieses Systems wird durch die kollaborativen Funktionen von Google-Tabellen noch verbessert, die es den Händlern ermöglichen, ihre Journale gemeinsam zu nutzen oder Feedback von Kollegen einzuholen. Durch den Einsatz dieses Systems können Händler Disziplin kultivieren, ihre psychologischen Faktoren verfolgen und letztendlich ihre Erfolgschancen auf den Finanzmärkten erhöhen.

In diesem Artikel entwerfen wir eine personalisierte Plattform für Händler, um ihre Geschäfte systematisch zu dokumentieren und zu verfolgen. Es enthält anpassbare Felder zur Reflexion von Strategien und Ergebnissen sowie integrierte Funktionen zur Automatisierung von Berechnungen, zur Reduzierung von Fehlern und zur Zeitersparnis. 

Wir zeigen Ihnen, wie Sie nutzerdefinierte Daten automatisch über das HTTP POST-Protokoll an eine Google-Tabelle senden können. Wir werden auch lernen, wie wir sie per HTTP-Anfrage im MetaTrader lesen oder abrufen können.

Verfügbare Lösungen

Um ein Handelsjournal einzurichten, müssen wir unsere Handelsdaten für zukünftige Analysen in eine Datenbank übertragen. Auf der anderen Seite müssen wir auf diese Datenbank zugreifen, die Informationen herunterladen und sie nutzen. Die Datenbank kann in beliebiger Form vorliegen, z. B. als Excel-Datei, als Datei im CSV-Format, als MySQL oder Microsoft SQL server, als  JSON oder auch als einfache Textdatei, in der die gewünschten Daten zeilenweise gespeichert sind. Je nachdem, um welche Art von Datenbank es sich handelt, unterscheiden sich Ihr Systemdesign und Ihre Entwicklung.

Wir haben mehrere Lösungstypen.

1. Google-Tabellen: Das Führen eines Handelsjournals kann durch die Verwendung von Google-Tabellen vereinfacht werden. Es handelt sich um eine einfach zu bedienende Schnittstelle zur Überwachung wichtiger Metriken wie Handelsgeschäfte, Einstiegs- und Ausstiegspunkte, Gewinne und Verluste sowie Anmerkungen zu den Handelsgeschäften. Durch die Verwendung eines Handelsjournals in Form einer öffentlichen Google-Tabelle können Händler ihre Handelsgeschäfte organisieren und Statistiken erstellen, um aus ihren Tätigkeit zu lernen. Darüber hinaus lassen sich Google-Tabellen individuell anpassen, sodass die Händler das Handelsjournal auf ihre spezifischen Strategien abstimmen können.
2. Handelsjournale mit Python und API: Für Händler, die eine anspruchsvollere Lösung suchen, kann die Automatisierung ihres Handelsjournals mithilfe von Python und Google-Tabellen API die Dateneingabe und -analyse erheblich rationalisieren. Diese Automatisierung ermöglicht Aktualisierungen in Echtzeit und reduziert das Potenzial für menschliche Fehler. Durch die Extraktion von Daten aus Handelsplattformen und das automatische Ausfüllen des Google-Tabellen können sich die Händler mehr auf die Analyse als auf die manuelle Dateneingabe konzentrieren. Diese Lösung ist besonders effektiv für diejenigen, die häufig handeln und eine genaue und zeitnahe Leistungsanalyse benötigen.
3. Online-Handelsjournal: Verschiedene Online-Handelsjournale kombinieren die Nutzerfreundlichkeit und Zugänglichkeit von Webanwendungen mit Funktionen, die es Händlern ermöglichen, ihre Geschäfte zu protokollieren, ohne eine Tabellenkalkulation manuell verwalten zu müssen, aber sie benötigen eine Abonnementgebühr. Diese Plattformen verfügen häufig über integrierte Analysetools, die Händlern helfen können, Muster in ihrem Handelsverhalten zu erkennen, was zu einer fundierteren Entscheidungsfindung führen kann.

Wir haben uns aus zwei wichtigen Gründen für Google-Tabellen als Excel-basierte Datenbank entschieden: Erstens ist es einfach und leicht zu verstehen. Zweitens sind Google-Tabellen von Natur aus eine Online-Datenbank, auf die von überall und auf jedem Computer über einen Link zugegriffen werden kann. Es ist nicht notwendig, eine zusätzliche Infrastruktur einzurichten, um die Daten online zugänglich zu machen.

Was ist eine Google-Tabelle?

Die Google-Tabelle ist eine kostenloses webbasiertes Excel-Tabelle von Google, mit dem Nutzer ihre Tabellenkalkulationen erstellen, bearbeiten und verwalten können. Ähnlich wie Microsoft Excel ermöglicht es den Nutzern, Daten in Zellen und Tabellen zu organisieren und mathematische, statistische und analytische Operationen mit Hunderten von Balken und Charts auszuführen.

Die wichtigsten Funktionen und Vorteile von Google-Tabellen sind:

• Die Dateien werden automatisch in Google Drive gespeichert, sodass sie von jedem Gerät mit einer Internetverbindung zugänglich sind.
• Mehrere Nutzer können gleichzeitig an der gleichen Datei arbeiten und die Änderungen der anderen Nutzer sofort sehen.
• Es ist keine Softwareinstallation erforderlich, sondern nur ein Browser und ein Google-Konto.
• Die Nutzer können Daten in Formaten wie Excel, CSV und PDF importieren und exportieren.
• Es unterstützt eine breite Palette von Funktionen zur Datenanalyse, ähnlich wie Excel.
• Google-Tabellen, Support-Skripte, Automatisierungsfunktionen, die auch über API-Lösungen zugänglich sind.

Google-Tabellen eignen sich hervorragend für die Online-Zusammenarbeit und den einfachen Zugriff auf Daten von überall aus. Sie eignen sich hervorragend für das Führen von Handelsjournalen.

Google-Tabellen API

Das Google-Tabellen-API ist eine RESTful-Schnittstelle, mit der Sie die Daten einer Kalkulationstabelle lesen und ändern können. Zu den häufigsten Verwendungszwecken dieser API gehören die folgenden Aufgaben:

• Tabellenkalkulationen erstellen
• Lesen und Schreiben von Tabellenkalkulationszellenwerten
• Tabellenkalkulationsformatierung aktualisieren
• Verbundene Blätter verwalten

Die Verwendung der API für die Google-Tabelle erfordert komplexe Schritte und ein Google-Entwicklerkonto mit einer Gebühr von 300 Dollar.

Aber wir hören hier nicht auf, wir bieten eine einfache und kostenlose Lösung. Lassen Sie uns Schritt für Schritt eintauchen:

Erstellen einer neue Google-Tabelle

1. Öffnen Sie zunächst eine Google-Tabelle und erstellen Sie ein neue leere Tabelle. Wenn Sie noch kein Google-Konto haben, müssen Sie ein neues Konto einrichten, um auf diesen Dienst zugreifen zu können. Diese Tabelle dient als primärer Speicherort für alle Daten, mit denen wir arbeiten werden, und ermöglicht uns das nahtlose Senden und Abrufen von Informationen für unser Handelsjournal.
2. Sobald die Tabelle geöffnet ist, müssen Sie die erste Zeile einrichten, indem Sie Überschriften hinzufügen, die den wichtigsten Datenpunkten entsprechen, die wir verwenden werden. Geben Sie in der ersten Zeile die folgenden Überschriften ein, eine pro Spalte:

• ticket: Ticket, Hier wird die eindeutige Kennung für jedes Handelsgeschäft eingetragen.
• order: Order, In dieser Spalte wird angezeigt, ob es sich um einen Kauf- oder Verkaufsauftrag handelt.
• symbol: Hier wird das Symbol des Handelsinstruments erfasst, z. B. Währungspaare wie EURUSD oder GBPJPY.
• openprice: Hier wird der Preis gespeichert, zu dem das Handelsgeschäft eröffnet wurde.
• sl: Ist für den Stop-Loss-Wert für den Handel festgelegt.
• tp:Steht für den Take-Profit-Wert, der für den Handel festgelegt wurde.
• close: In dieser Spalte wird angezeigt, ob der Handel abgeschlossen wurde oder nicht.
• Los: Hier werden die Losgröße eingetragen, d. h. das Volumen des Handels.
• opentime: In dieser Spalte wird der genaue Zeitpunkt der Eröffnung des Handelsgeschäfts festgehalten.

note: Bei den Spaltennamen wird in unserem Projektcode zwischen Groß- und Kleinschreibung unterschieden. Vergewissern Sie sich also, dass Sie sie verstehen, wenn Sie sie (Spaltennamen) mit Ihrem Stil ändern möchten.

Ein Google Apps-Skript erstellen

Um Ihrer Google-Tabelle Funktionen hinzuzufügen, müssen Sie im nächsten Schritt ein Google Apps Script erstellen. Mit Google Apps Script können Sie nutzerdefinierten Code schreiben, der Aufgaben automatisiert und Google-Dienste miteinander verbindet.

Um das zu tun:

• Klicken Sie in Ihrer Google-Tabellen auf das Menü „Erweiterungen“ (Extensions) am oberen Rand.
• Wählen Sie aus dem Dropdown-Menü „Apps Script“. Diese Aktion öffnet eine neue Registerkarte, die Sie zur Google Apps Script-Schnittstelle führt, wo Sie Code schreiben und bearbeiten können, um Interaktionen mit Ihrer Tabelle zu automatisieren.
• Sobald der Apps Script Editor geöffnet ist, sehen Sie einen leeren Script Editor. Es ist eine gute Idee, Ihrem Projekt einen aussagekräftigen Namen zu geben, damit es in Zukunft leicht zu identifizieren ist.
• Sie können es „Mein erstes Journal“ oder „Meine Handelslistenfunktion“ nennen, wie immer Sie wollen.
• Nachdem Sie den Google Apps Skript-Editor geöffnet und Ihr Projekt benannt haben, müssen Sie als Nächstes das Skript ändern, indem Sie den angezeigten Standardcode entfernen. Google Apps Script enthält standardmäßig eine einfache Funktionsvorlage namens „myFunction“, die wir für unser Projekt nicht benötigen.

Entfernen Sie also die Standardfunktion, kopieren Sie dann die folgende Funktion und fügen Sie sie ein, und ersetzen Sie die Standardfunktion durch Ihr eigenes nutzerdefiniertes Skript:

// Original code from https://github.com/jamiewilson/form-to-google-sheets
const sheetName = 'Sheet1'
const scriptProp = PropertiesService.getScriptProperties();

function initialSetup() {  
const activeSpreadsheet = SpreadsheetApp.getActiveSpreadsheet();
scriptProp.setProperty('key', activeSpreadsheet.getId());
}

function doPost (e) {  
  const lock = LockService.getScriptLock();
  lock.tryLock(10000);
  
  try {    
    const doc = SpreadsheetApp.openById(scriptProp.getProperty('key'));    
    const sheet = doc.getSheetByName(sheetName);
    const headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
    const nextRow = sheet.getLastRow() + 1;
    const newRow = headers.map(function(header) {      
      return header === 'Date' ? newDate() : e.parameter[header];
    })
 
    sheet.getRange(nextRow, 1, 1, newRow.length).setValues([newRow]);

    return ContentService      
      .createTextOutput(JSON.stringify({ 'result': 'success', 'row': nextRow }))
      .setMimeType(ContentService.MimeType.JSON);
  }
  catch (e) {
    return ContentService
      .createTextOutput(JSON.stringify({ 'result': 'error', 'error': e }))
      .setMimeType(ContentService.MimeType.JSON);
  }
  finally {
    lock.releaseLock();
  }}

Dank an Jamie Wilson, da wir seinen Code (form-to-google-sheets) für unser Projekt verwendet haben

Speichern Sie nun das Projekt, bevor wir zum nächsten Schritt übergehen. Datei > Symbol zum Speichern

Diese Funktion ist Teil eines Google Apps-Skripts, das ein Google-Formular oder eine externe HTTP-POST-Anfrage mit einer Google-Tabelle verbindet, sodass Daten dynamisch in dem Tabelle gespeichert werden können.

Hier ist eine Aufschlüsselung der Funktionskomponenten:

sheetName: ist eine globale Variable, die auf unser neues, zuvor erstelltes Arbeitsblatt verweist. Der Standardtabellenname ist „sheet1“.

scriptProp: Dies wird verwendet, um skriptspezifische Eigenschaften über den PropertiesService in Google Apps Script zu speichern, was eine dauerhafte Speicherung von Werten wie der Tabellenkalkulations-ID ermöglicht.

initialSetup: Mit dieser Funktion rufen wir die derzeit aktive Google-Tabelle mit SpreadsheetApp.getActiveSpreadsheet() ab und speichern dann die eindeutige ID der Tabelle in den Skripteigenschaften mit scriptProp.setProperty('key', activeSpreadsheet.getId()). Dadurch können andere Teile des Skripts später über die ID auf die Tabelle zugreifen.

doPost ist unsere Hauptfunktion, die eingehende HTTP-POST-Anfragen verarbeitet, indem sie die empfangenen Daten einer Google-Tabelle zuordnet. Es erwirbt zunächst eine Sperre, um gleichzeitige Schreibprobleme zu verhindern, ruft dann die Ziel-Tabelle anhand seiner gespeicherten ID ab und identifiziert die richtige Tabelle. Die Funktion liest die Kopfzeilen der ersten Zeile, um die eingehenden Daten den entsprechenden Spalten zuzuordnen, fügt die Daten an die nächste verfügbare Zeile an und behandelt „Date“ in der Kopfzeile so, dass sie automatisch das aktuelle Datum einfügt. Sie gibt eine Erfolgsmeldung im JSON-Format zurück, wenn der Vorgang abgeschlossen ist, oder eine Fehlermeldung, wenn Probleme auftreten, und gibt schließlich die Sperre frei.

Ausführen der Einrichtungsfunktion

Da dieses Skript nicht von Google überprüft wurde, wird eine Warnung angezeigt, bevor Sie fortfahren können. Dies ist ein Standardverfahren für ungeprüfte Skripte.

Um die Funktion auszuführen und Ihr Google Apps Script richtig zu konfigurieren:

1. Klicken Sie auf das Symbol Ausführen neben dem Symbol Speichern.
2. Es erscheint ein modales Fenster mit dem Hinweis „Autorisierung erforderlich“. Klicken Sie auf „Berechtigungen überprüfen“ (Review permissions), um zum nächsten Bildschirm zu gelangen, auf dem Sie dem Skript den Zugriff auf Ihr Google-Konto gestatten müssen.
3. Wählen Sie das Google-Konto, das Sie mit diesem Skript verwenden möchten. Dies ist das Konto, das die erforderlichen Berechtigungen erteilt.
4. Auf dem nächsten Bildschirm sehen Sie möglicherweise die Meldung „Google hat diese App nicht überprüft“.  Dies ist eine häufige Warnung für Skripte, die den Verifizierungsprozess von Google nicht durchlaufen haben. Um fortzufahren, klicken Sie auf „Erweitert“ (Advanced).
5. Nachdem Sie auf Erweitert geklickt haben, sehen Sie die Option „Gehe zu Unbenanntes Projekt (unsicher)“ (Go to Untitled project (unsafe)). Diese Meldung zeigt an, dass das Skript zwar nicht verifiziert ist, Sie ihm aber dennoch Zugriff auf Ihr Google-Konto gewähren. Klicken Sie auf diesen Link, um fortzufahren.
6. Schließlich werden Sie aufgefordert, dem Skript Rechte zu erteilen. Überprüfen Sie die angeforderten Berechtigungen und klicken Sie auf „Zulassen“ (Allow), um das Skript für die Interaktion mit Ihrer Google-Tabelle und anderen Google-Diensten zu autorisieren.

Nachdem Sie dem Skript die erforderlichen Berechtigungen erteilt haben, sehen Sie in der Konsole des Skripteditors ein Ausführungsprotokoll, das anzeigt, dass das Skript zur Ausführung autorisiert wurde. Jetzt ist das Skript fertig, aber um seine Ausführung durch HTTP-POST-Anfragen zu automatisieren, müssen Sie einen Trigger einrichten.

---

Um das zu tun:

1. Klicken Sie auf der Seite des Google Apps Script Editors in der linken Seitenleiste auf „Trigger“, um die Verwaltungsoberfläche des Triggers zu öffnen. In diesem Abschnitt können Sie festlegen, wann und wie Ihr Skript ausgeführt werden soll.
2. Klicken Sie auf der Seite „Trigger“ auf die Schaltfläche „Trigger hinzufügen“. Diese Schaltfläche wird in der Regel durch ein Plus-Symbol (+) dargestellt oder ausdrücklich als „Trigger hinzufügen“ bezeichnet.
3. Es wird ein neues Dialogfeld angezeigt, in dem Sie die Details Ihres Auslösers konfigurieren können. Sie müssen den Auslöser so einrichten, dass er Ihre Funktion (doPost) als Reaktion auf eine HTTP-POST-Anforderung aktiviert.
4. Wählen Sie für die Ereignisquelle „Aus der Web-App“ (From the web app) oder „Web-App“ (die genaue Option kann je nach Aktualisierungen der Google Apps Script-Schnittstelle variieren).
5. Wählen Sie die Funktion, die Sie auslösen möchten, aus dem Dropdown-Menü. In diesem Fall wählen Sie doPost.
6. Wählen Sie, welche Verteilung ausgeführt werden soll:  Head
7. Wählen Sie die Ereignisquelle:  From spreadsheet (aus Tabelle)
8. Setzen Sie den Ereignistyp auf „On form submit“ (Beim Absenden des Formulars). Diese Konfiguration ermöglicht die Ausführung Ihres Skripts als Antwort auf eine HTTP-POST-Anfrage, die an die URL der Webanwendung gesendet wird.

Klicken Sie dann auf SAVE (Speichern). Wenn Sie Genehmigungen benötigen, müssen Sie diese über Ihr Google-Konto akzeptieren.

Veröffentlichen des Projekts als Webanwendung

Nun müssen wir das Projekt veröffentlichen, indem wir auf der Seite App auf die blaue Schaltfläche Deploy (Bereitstellen) klicken und in der Dropdown-Liste auf New Deployment klicken.

Klicken Sie dann auf das Symbol „Select type“ (Typ auswählen) und wählen Sie Webanwendung.

Wählen Sie in dem daraufhin angezeigten Formular die folgenden Optionen aus:

• Beschreibung: Das kann alles sein, was Sie wollen. Machen Sie es einfach selbsterklärend.
• Web app → Ausführen als:  Ich
• Web app → Wer hat Zugriff:  Jeder

Klicken Sie dann auf Deploy (Bereitstellen).

Das ist wichtig: Kopieren Sie auf der nun erscheinenden Seite die URL der Webanwendung, die wir in unserem Projekt verwenden. Ihr Link wird in etwa so aussehen:

Projekt-Link: https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec

Wie man Daten in Google-Tabellen postet (schreibt)

HTTP POST ist eine Methode des HTTP-Protokolls, um Daten vom Client an den Server zu senden. Sie wird in der Regel bei der Übermittlung von Formulardaten auf Websites verwendet. Sie sehen eine Menge davon im Web, genau wie das Anmeldeformular auf der MQL-Website.

Die Daten werden im Gegensatz zur GET-Methode, bei der die Daten in der URL übergeben werden, im Body der Anfrage übertragen. Bei der Verwendung der Post-Methode sind die Daten in der URL nicht sichtbar, sodass sie etwas sicherer ist und die Größe der gesendeten Daten nicht begrenzt ist, was die Übermittlung großer Dateien oder Daten ermöglicht.

Um die Funktion unseres Skripts zu testen, erstellen wir ein einfaches HTML-Formular, mit dem wir die Testdaten erfassen und zur Verarbeitung an den Server senden. Die Sendemethode des Formulars muss auf POST eingestellt sein.

Das unten stehende HTML-Formular enthält:

Action: Es muss durch Ihren Projektlink eingetragen werden (aus den vorherigen Veröffentlichungsschritten)

Method: Es ist das Formular Post-Methode, könnte auf GET oder POST-Methode sein.

Da wir unser App-Skript auf der Google-Tabelle mit der post-Methode schreiben, verwenden wir post, um Daten an Google zu senden.

input: Es enthält alle Arten von Daten, die wir senden wollen.

Dies ist unser endgültiges HTML-Formular:

<!DOCTYPE html>
<htmllang="en">
<head>
<metacharset="UTF-8">
</head>
<body>
<form method="post" action="https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec">
<input type="number" size="20" name="ticket" placeholder="ticket">
<input type="text" size="20" name="order" placeholder="order">
<input type="text" size="20" name="symbol" placeholder="symbol"><br>
<input type="number" step="0.00001" size="20" name="openprice" placeholder="openprice">
<input type="number" step="0.00001" size="20" name="sl" placeholder="stoploss">
<input type="number" step="0.00001" size="20" name="tp" placeholder="takeprofit"><br>
<input type="number" step="0.00001" size="20" name="close" placeholder="close price">
        <input type="number" step="0.01" size="20" name="lot" placeholder="volume">
        <input type="datetime-local" size="20" name="opentime" placeholder="opentime">
<input type="submit" value="post">
</form>
</body>
</html>

Kopieren Sie diesen Text und fügen Sie ihn in eine lokale Textdatei ein und benennen Sie das Dateiformat in eine HTML-Datei um. Etwa so: „newfile.html“

Ersetzen Sie auch die Adresse der Formularaktion durch die Linkadresse Ihres Tabellenprojekts.

Jetzt können wir ganz einfach, die gewünschten Daten an eine Google-Tabelle senden.

Füllen Sie die Formulareingaben aus, klicken Sie auf „Posten“ und warten Sie auf die Aktualisierung Ihrer Google-Tabelle.

Wenn Sie diesen Schritt erfolgreich abgeschlossen haben, gehen wir zum nächsten Schritt über, andernfalls lesen Sie die obigen Schritte noch einmal genauer durch. Überprüfen Sie Ihre Tabellenspalten und vergleichen Sie sie mit den Namen Ihrer HTML-Formulareingaben.

Das oben verwendete Formular ist nur ein Test für das Senden von Daten per HTML POST. Im weiteren Verlauf dieses Artikels werden wir die Transaktionsdaten automatisch mit der MetaTrader-Funktion WebRequest senden.

Wie man Google-Tabellen über HTTP liest und darauf zugreift

Um mit der HTTP-Methode Daten aus einer Tabelle zu lesen, müssen Sie für Ihre Tabelle eine Leseberechtigung festlegen.

Öffnen Sie die Google-Tabelle, suchen Sie Ihre zuvor erstellte Tabelle und öffnen Sie sie.

Klicken Sie auf der Tabellenseite oben rechts auf Freigabe und setzen Sie den allgemeinen Zugriff auf „Anyone with the link“ (Jeder mit dem Link) und die Rolle auf „Viewer“ (Betrachter).

Klicken Sie dann auf „Copy link“ (Link kopieren), um ihn als Link für den Zugriff auf die Tabelle zu verwenden. Der Zugangslink sieht folgendermaßen aus:

https://docs.google.com/spreadsheets/d/1rYNuscaYWtRu_65W-fPnascNTYHwcU-3fWiNQ4asTBHQo/edit

Der fettgedruckte Text ist Ihre Tabellen-ID

Wir benötigen diese ID, um die Tabelle im JSON-Typ zu lesen.

Zugangslink: https://docs.google.com/spreadsheets/d/{YOUR_SHEET_ID}/gviz/tq?tqx=out:json&tq&gid='+gid

{YOUR_SHEET_ID} ist die ID Ihrer Tabelle, die in der URL Ihrer Tabelle zu finden ist.

Kopieren Sie die ID aus der Tabellen-URL und ersetzen Sie {YOUR_SHEET_ID} im Zugriffslink. Der Zugriffslink sieht dann wie folgt aus:

https://docs.google.com/spreadsheets/d/1rYNuscaYWtRu_65W-fPnascNTYHwcU-3fWiNQ4asTBHQo/gviz/tq?tqx=out:json&tq&gid='+gid

Wenn Sie diesen Link in Ihrem Browser verwenden, werden die vollständigen Angaben zu Ihrer Tabelle in einem JSON-Dateiformat heruntergeladen.

Das Ergebnis ist wie folgt:

google.visualization.Query.setResponse(
{
    "version": "0.6",
    "reqId": "0",
    "status": "ok",
    "sig": "529900317",
    "table":
    {
        "cols": [
        {
            "id": "A",
            "label": "ticket",
            "type": "number",
            "pattern": "General"
        },
        {
            "id": "B",
            "label": "order",
            "type": "string"
        },
        {
            "id": "C",
            "label": "symbol",
            "type": "string"
        },
        {
            "id": "D",
            "label": "openprice",
            "type": "number",
            "pattern": "General"
        }],
        "rows": [
        {
            "c": [
            {
                "v": 5.64123564E8,
                "f": "564123564"
            },
            {
                "v": "buy"
            },
            {
                "v": "EURUSD"
            },
            {
                "v": 1.2215,
                "f": "1.2215"
            },
            {
                "v": 1.21,
                "f": "1.21"
            },
            {
                "v": 1.23,
                "f": "1.23"
            },
            {
                "v": 0.0,
                "f": "0"
            },
            {
                "v": 0.01,
                "f": "0.01"
            },
            {
                "v": "Date(2024,8,11,18,27,0)",
                "f": "2024-09-11 18:27"
            }, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            {
                "v": null
            }]
        },
        {
            "c": [
            {
                "v": 123123.0,
                "f": "123123"
            },
            {
                "v": "sell"
            },
            {
                "v": "USDJPY"
            },
            {
                "v": 147.22,
                "f": "147.22"
            },
            {
                "v": 147.44,
                "f": "147.44"
            },
            {
                "v": 146.0,
                "f": "146"
            },
            {
                "v": 0.0,
                "f": "0"
            },
            {
                "v": 0.02,
                "f": "0.02"
            },
            {
                "v": "Date(2024,8,4,20,43,0)",
                "f": "2024-09-04 20:43"
            }, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            {
                "v": null
            }]
        }],
        "parsedNumHeaders": 1
    }
});

Es enthält alle Spaltennamen, Zahlen und Werte. Alle oben genannten Daten beziehen sich nur auf 2 Zeilen mit Positionsangaben.

Wir verwenden diese JSON-Datei, um die Tabelle in unserem Expert Advisor zu lesen.

Kommen wir nun zum interessantesten Teil der Geschichte, nämlich der automatischen Umsetzung all dessen, was wir in der Metatrader-Plattform gesagt haben

Implementierung und Aktualisierung von Tools für unser Trading Journal mit MetaTrader

Um ein Handelsjournal in einer Google-Tabelle mit MetaTrader zu implementieren, sind einige wichtigst Schritte erforderlich.

Zunächst müssen wir eine Google-Tabelle erstellen, um Handelsdetails, einschließlich Positionsdetails oder Positionskommentare, zu speichern und zu verwalten. Wir haben es schon einmal getan.

Als Nächstes verwenden wir das Google Apps Script, damit das Tabelle über HTTP-Anfragen mit externen Systemen interagieren kann. Das haben wir auch schon getan.

In MetaTrader werden wir nun einen nutzerdefinierten Expert Advisor schreiben, der Handelsdaten (z. B. Symbol, Volumen und Ordertyp) mithilfe der WebRequest-Funktion und des HTTP POST-Protokolls an das Google-Tabelle sendet. Die Tabelle fungiert als Cloud-Datenbank und ermöglicht uns die Überwachung, Speicherung und gemeinsame Nutzung von Geschäften in Echtzeit über verschiedene Konten und Standorte hinweg.

Erstellen eines Expert Advisors, um Daten zu posten

Wir benötigen einen Expert Advisor, der Positions- und Auftragsdetails an das Google-Tabelle sendet.

Wir brauchen also zwei Hauptteile in unserem Code.

1. Eine Funktion mit der Aufgabe, offene Positionen und schwebende Aufträge auf einem Konto im MetaTrader zu überprüfen. Wir nennen das „OrderList“.
2. Eine Funktion mit der Aufgabe, die Daten der „OrderList“ per WebRequest-Funktion an unser Google-Tabelle zu senden. Wir nennen das „UpdateDatabase“.

Abrufen der Liste der laufenden Orders und Positionen

Unsere Funktion „OrderList“ kann eine solche Struktur haben:

void OrderList {
   for(int conter = PositionsTotal() - 1; conter >= 0; conter -= 1)
   {
      const ulong ticket = PositionGetTicket(conter);
      if(ticket == 0 || !PositionSelectByTicket(ticket)) continue;
      string   symbol      =  PositionGetString(POSITION_SYMBOL);
      int      order_type  =  PositionGetInteger(POSITION_TYPE);
      double   volume      =  PositionGetDouble(POSITION_VOLUME);
      double   open_price  =  PositionGetDouble(POSITION_PRICE_OPEN);
      datetime open_time   =  PositionGetInteger(POSITION_TIME);
      double   stop_loss   =  PositionGetDouble(POSITION_SL);
      double   take_profit =  PositionGetDouble(POSITION_TP);      
      // Send trade details via WebRequest
      UpdateDatabase(symbol, order_type, volume, open_price, stop_loss, take_profit, ticket, open_time);
   }
} 

und für MQL4 könnte der Code wie folgt aussehen:

void OrderList {
   // Loop through all open trades
   for(int conter = OrdersTotal() - 1; conter >= 0; conter -= 1) {
      if(OrderSelect(conter, SELECT_BY_POS, MODE_TRADES)) {
         // Collect trade data
         int      ticket      =  OrderTicket();
         string   symbol      =  OrderSymbol();
         int      order_type  =  OrderType();
         double   volume      =  OrderLots();
         double   open_price  =  OrderOpenPrice();
         datetime open_time   =  OrderOpenTime();
         double   stop_loss   =  OrderStopLoss();
         double   take_profit =  OrderTakeProfit();
         // Send trade details via WebRequest
         UpdateDatabase(symbol, order_type, volume, open_price, stop_loss, take_profit, ticket, opentime);
      }
   }
}

Dieser Funktionscode enthält einen Schleifenstart von 0 bis zur Gesamtzahl der offenen Aufträge OrdersTotal() oder PositionsTotal().

Jede Schleife wählt eine Position oder Aufträge aus der MetaTrader-Auftragsliste aus und wählt sie dann mit der Funktion OrderSelect aus.

Dann lesen wir die gewünschten Informationen mit PositionGetString, PositionGetDouble und PositionGetInteger.

Alles, was Sie an Details für andere Daten benötigen, finden Sie hier für MQL4 Trade Functions und MQL5 Trade Functions.

Senden von Auftragslistendaten an Google-Tabelle

Nachdem wir alle Auftragsdetails aus der Vorschaufunktion „OrderList“ erhalten haben, benötigen wir nun eine weitere Funktion namens „UpdateDatabase“, um die Daten der OrderList in unsere Tabelle zu übertragen.

Positionsdetails wie das Symbol, die Auftragsart, das Volumen, der offene Preis, der Stop-Loss, der Take-Profit und die Ticketnummer als Funktionseingaben und bereiten sie in einem formatierten String auf. Diese Daten werden dann mit einer HTTP-POST-Anfrage über die Funktion WebRequest() gesendet. Wenn die Anfrage erfolgreich ist, wird bestätigt, dass die Handelsdaten gesendet wurden; wenn nicht, wird eine Fehlermeldung ausgegeben.

void SendTradeData(string orderSymbol, int orderType, double orderVolume, double openPrice, double stopLoss, double takeProfit, ulong orderTicket, datetime openTime)
{ 
   // Database url. Replace with your own url
   string url  = "https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec";
   int   digit = (int)SymbolInfoInteger(orderSymbol,SYMBOL_DIGITS);
   string datastring = "?
                  +"&ticket="+string(orderTicket)
                  +"&order="+string(orderType)
                  +"&symbol="+string(orderSymbol)
  +"&openprice="+DoubleToString(openPrice,digit)
                  +"&sl="+DoubleToString(stopLoss,digit)
                  +"&tp="+DoubleToString(takeProfit,digit)
                  +"&close=0"
  +"&lot="+DoubleToString(orderVolume,2)
  +"&opentime="+(string)openTime;   

   int   res;     // To receive the operation execution result
   char  data[];  // Data array to send POST requests  
   char  result[];
   //--- Create the body of the POST request for authorization
   ArrayResize(data,StringToCharArray(datastring,data,0,WHOLE_ARRAY,CP_UTF8)-1);
   ResetLastError();
   res=WebRequest("POST", url, NULL, 0, data, result, str);
   string responsestring   = CharArrayToString(result, 0, 0, CP_UTF8);
   Print(responsestring);
   if(res == -1)
      Print("Error in WebRequest: ", GetLastError());
   else
      Print("Trade data sent: ", data);
}

In dieser Funktion erhalten wir Aufträge oder Positionsdaten aus der Funktion „OrderList“ und bereiten sie für eine Standard-Post-Methode vor.

Die URL ist unsere öffentliche Tabellen-URL.

Dann erstellen wir eine String-Variable „datastring“ mit dem Format der GET-Methode.

Mit der Funktion StringToCharArray speichern wir die Zeichenkette in einem Array mit diesem Namen, data.

Die in der nächsten Zeile eingeleitete WebRequest-Funktion mit der MethodePOST-Methode, „url“, unserem Array „data“ und dem Antwort-String, der in der Variable „result“ gespeichert ist.

Dann konvertieren wir das Antwort-Array in eine Zeichenkette „responsestring“, um sie in den MetaTrader-Expert-Tab-Logs auszugeben.

Einfache Analyse zu unserer Handelsliste

Jedes Mal, wenn Sie eine Auftrag absenden, wird Ihre Tabelle aktualisiert, und Sie können alle Daten mit dem Analysediagramm der Google-Tabelle analysieren.

Berechnen der Gesamtzahl der Kaufpositionen, der Gesamtzahl der Verkäufe, der Gesamtzahl der Aufträge, der Gesamtzahl der Gewinn- oder Verlustpositionen, den durchschnittlichen Gewinn, den durchschnittlichen Verlust oder alles, was Ihnen in den Sinn kommen könnte.

Wir haben eine Vorlage für Ihr Handelsjournal erstellt, die Sie über diesen Link aufrufen können. Überprüfen Sie die Spaltenformel, um herauszufinden, wie wir Details aus der Rohpositionsliste berechnen und analysieren.

https://docs.google.com/spreadsheets/d/1rYcRJKzVWtRu_65W-fPnQgODSzTU-3fWiNQHZz3P2Qo/edit?usp=sharing

Schlussfolgerung

In diesem Artikel haben wir die Erstellung eines Handelsjournals mit Google-Tabellen und die Verknüpfung mit MetaTrader zur automatischen Datenverfolgung beschrieben. Wir haben das Einrichten des Google-Tabelle, das Hinzufügen von Kopfzeilen und die Verwendung von Google Apps Script zum Senden von Handelsdaten über HTTP POST-Anfragen behandelt. Dieses System spart Zeit und reduziert Fehler, da es die Verfolgung von Handelsgeschäften in Echtzeit erleichtert.

Wir haben auch gelernt, wie man einen Expert Advisor in MetaTrader erstellt, um Handelsdetails direkt an Google-Tabellen zu senden und so Echtzeitanalysen zu ermöglichen. Mit dieser einfachen Einrichtung haben Sie nun eine effiziente Möglichkeit, Ihre Handelsleistung zu organisieren und zu verbessern, ohne komplexe Tools zu benötigen.

Wir haben für Sie die notwendigen Codes für zwei Versionen von MetaTrader 4 und 5 vorbereitet.

Wenn Sie Fragen oder Anregungen haben, zögern Sie nicht, einen Kommentar zu hinterlassen.