Als Entwickler kann ich nicht anders, als auf die enorme Menge an Stiefzählungs- und Schlafgewohnheitsdaten zugreifen, die mein Kieferknochen auf mich hat. Es gibt so viele Daten! Also begann ich zu untersuchen
Ich habe Beispiele dafür gefunden, wie man mit der API und dem Knoten des Kieferbeins im Internet arbeitet, aber sie waren alle ziemlich involviert und hatten viele bewegliche Teile, zusammen mit einigen veralteten Modulen (wie älteren Versionen von Express). In diesem Artikel möchte ich mich auf die absoluten Grundlagen konzentrieren - keine Sorgen, Benutzerdaten in einer Datenbank zu speichern, Konten zu erstellen oder soziale Anmeldungen zu verbinden. Wir konzentrieren uns auf die Kern von Dingen, die Sie wissen müssen, um einen Knotenserver mit der Jawbone -API zu authentifizieren und Benutzerdaten zurückzugeben.Der gesamte Code für diese Demo ist in unserem GitHub Repo verfügbar.
Key Takeaways
Beginnen Sie mit der Anmeldung in den Entwicklerbereich der Jawbone -Website, indem Sie unter https://jawbone.com/up/developer und auf den Link "Anmelden" unten links klicken. Sie benötigen kein bestimmtes Jawbone -Entwicklerkonto, da Sie sich mit einem vorhandenen Jawbone -Konto anmelden können.
Besuchen
Auf dieser Seite erreichen Sie Ihre Entwicklerkontoseite. Klicken Sie hier auf "App erstellen".
Auf der geladenen Seite werden Sie aufgefordert, die Details Ihrer App einzugeben:
Sobald Sie klicken, um die Anwendung zu erstellen, werden Sie mit einer Liste Ihrer Apps auf die Seite geleitet. Ihre neu erstellte App sollte meiner ähnlich aussehen:
Beachten Sie die "Client -ID" und "App Secret" - das müssen Sie mit der Jawbone -API verbinden.
Ich werde unseren gesamten Node Server -Code in eine Datei namens Server.js einbeziehen. Wir benötigen zunächst die erforderlichen NPM -Module für unseren Server.
Erstens haben wir eine grundlegende Express -App eingerichtet.
<span>var express = require(‘express’), </span> app <span>= express(),</span>
Wir benötigen dann EJs (eingebettete JavaScript), mit dem wir JavaScript in unsere HTML -Vorlagen einfügen können. Wir werden dies verwenden, um JavaScript -Variablen in unserem zurückgegebenen HTML anzuzeigen.
ejs <span>= require('ejs'),</span>Um sich mit der Jawbone -API authentifizieren zu können und zu unserer Anwendung zurückzuführen, verlangt Jawbone, dass wir zu einer Seite über HTTPS umleiten. Dazu müssen wir https einbeziehen.
https <span>= require('https'),</span>Als nächstes schließen wir FS ein, mit dem wir das Dateisystem lesen können. Wir müssen dies in Serverzertifikatdateien lesen, um HTTPS zu aktivieren.
fs <span>= require('fs'),</span>Wir brauchen auch Body-Parser, damit wir JSON-Anfragen behandeln können:
bodyParser <span>= require('body-parser'),</span>Die API von Jawbone Up verwendet das OAuth 2.0 -Protokoll zur Authentifizierung. Grundsätzlich bedeutet dies, dass sich ein Benutzer mit ihrem Jawbone -Konto anmeldet und uns die Erlaubnis zum Zugriff auf ihre Daten erteilt. Wir müssen dieses Protokoll durchlaufen. Glücklicherweise enthält das Passport-Modul von NPM ein Modul namens Passport-OAUTH, das dies unterstützt. Wir haben den Reisepass in unserer App zusammen mit OAuth 2.0 wie SO:
eingerichtetpassport <span>= require('passport'),
</span><span>JawboneStrategy = require('passport-oauth').<span>OAuth2Strategy</span>,</span>Wir haben dann eine selbsterklärende Variable, die den Port speichert, auf dem wir ausgeführt werden.
port <span>= 5000,</span>
Als nächstes werden wir alle für die Authentifizierung im Pass und OAuth 2.0 in JawboneAuth benötigten Werte speichern. Dies ist der Moment, in dem Sie die Werte "Client -ID" und "App Secret" verwenden, die wir früher zur Kenntnis genommen haben, als wir unsere App registriert haben.
<span>var express = require(‘express’), </span> app <span>= express(),</span>
Hier ist ein Überblick darüber, was diese Werte bedeuten und/oder woher sie stammen:
Die letzte Variable, die wir definieren müssen, sind unsere SSLOPTIONS, die alle Details enthält, die wir unserem Server angeben müssen, damit wir diesen Server mithilfe von HTTPS ausführen können. Ich werde jeweils später in diesem Artikel ausführlich durchgehen, wenn ich erläutere, wie wir https einrichten.
Wir geben dann einige Zeilen ein, die einige grundlegende Node App -Funktionen definieren, die den Knotenentwicklern da draußen vertraut sind:
ejs <span>= require('ejs'),</span>Um den Pass in Express zu initialisieren, führen wir die folgende Zeile aus:
https <span>= require('https'),</span>Als Notiz gibt es im Reisepass noch mehr, wenn wir anhaltende Anmeldessionen haben wollten. In diesem Fall müssten wir Sitzungen einrichten. Für dieses Tutorial konzentrieren wir uns jedoch nur auf die Anfangsphase, die Daten von der API der Jawbone -Up -API abzubauen, und machen uns keine Sorgen um Anmeldesitzungen.
Um den Benutzer auf einen Anmeldebildschirm für die API von Jawbone Up zu lenken, müssen wir auf unserem Server eine URL zuweisen, die dem Anmeldebeinbildschirm Jawbone umgeleitet wird. Der folgende Code weist zu diesem Zweck die URL von /login /Jawbone zu. Auf eine Get -Anfrage an diese URL rufen wir Passport.Authorize () an, um unsere Seite "Jawbone Up Authorization" zu erheben:
<span>var express = require(‘express’), </span> app <span>= express(),</span>
Wie Sie oben sehen können, haben wir eine Reihe spezifischer Berechtigungen, die wir fragen - ['Basic_read', 'sleep_read']. In unserem Fall fragen wir nach grundlegenden Benutzerdaten und Schlafdaten. Wenn Sie Zugriff auf die Stufenzahl, die gegessenen Mahlzeiten usw. anfordern möchten, können Sie diesem Array zusätzliche Berechtigungsanfragen hinzufügen. Sie können eine Liste der verfügbaren verfügbaren und auf das Jawbone UP -Entwickler -Authentifizierungs -Dokumentationsseite sehen.
Beachten Sie auch, dass es uns wieder auf die Homepage umgeleitet wird, wenn es einen Fehler bei der Authentifizierung im Authentifizierungsbildschirm der Kieferbone -UP -Authentifizierung gibt. Es ist im Passmodul möglich, SuccessReDirect auch festzulegen, aber ich habe mit der API der Jawbone Up -API festgestellt. Es ist nicht erforderlich, da wir unsere Rückruf -URL in der Jawbonestrategy weiter unten in diesem Code definieren.
Wir haben dann die GET -Anfrage eingerichtet, auf die unsere Schlafdaten angezeigt werden. Dies ist der Ort, an dem wir der API sagen werden, dass sie uns umleiten soll, wenn wir Zugriff auf die Benutzerdaten haben. In diesem Beispiel ist es /sleepData:
ejs <span>= require('ejs'),</span>Wir haben hier die gleiche Passform.Authorize () -Funktion, um zu überprüfen, ob der Benutzer bis zum Erreichen dieser Seite angemeldet ist. In diesem Fall führen wir res.render ('userData', req.account) aus; Dies gibt die Daten über, dass die API der Kieferbone auf die userData.ejs -Vorlage zurückgegeben hat (die wir in Kürze einrichten werden). Wenn sie nicht angemeldet sind, werden sie zurück zum Authentifizierungsbildschirm des Kieferknochens gerichtet.
Wir haben dann eine URL festgelegt, damit der Benutzer sich bei /logout anmeldet, wodurch der Benutzer nach dem Auskaufen auf die Homepage zurückgeleitet wird:
https <span>= require('https'),</span>Schließlich setzen wir es für unser Routing, um unsere Index.ejs -Vorlage zu laden, wenn jemand versucht, auf die Homepage zuzugreifen:
fs <span>= require('fs'),</span>Der größte Teil des Codes ist ebenfalls die wichtigste - die Einrichtung einer Passport -Strategie, um den Passport mitzuteilen, wie Anfragen zur Genehmigung mit "Jawbone" bearbeitet werden. Es sieht so aus:
bodyParser <span>= require('body-parser'),</span>Lassen Sie uns überlegen, was all dieser Code tut.
Erstens haben wir unsere ClientID, ClientSecret, Authorizationurl, Tokenurl und Callbackurl von unserem JawbonEAUTH -Objekt eingerichtet, das wir zu Beginn der Datei definiert haben. Dies geschieht mit New Jawbonestrategy ().
Als nächstes haben wir unsere Rückruffunktion, die diese Daten übernimmt. Wir verwenden das Token- und Fertig -Werte in dieser Rückruffunktion. Token ist das API -Zugriffs -Token von Jawbone UP, das wir mit Anrufen der API aufnehmen müssen, um zu beweisen, dass wir authentifiziert sind. Erledigt ist die Rückruffunktion, die unsere Daten in die App zurückgibt.
Wir geben zusammen mit der Client-ID und dem früheren Geheimnis in das Jawbone-up-Modul innerhalb des Optionsobjekts:
, zusammen mit der Client-ID ein:<span>var express = require(‘express’), </span> app <span>= express(),</span>
Das Jawbone-Up-Modul ist das Knotenmodul, mit dem wir Zugriff auf die API-Endpunkte der Jawbone Up API erhalten. Dies sind die Anrufe, die wir an die API tätigen, um Benutzerdaten zurückzugeben (z. B. https://jawbone.com/nududy/api/v.1.1/users/@me/sleeps) Diese in Funktionen wie up.moves.get () und up.sleeps.get (). In unserem Beispiel werden wir up.sleeps.get () verwenden, um Schlafdaten zu erhalten.
In up.sleeps.get () haben wir zwei Variablen, ERR und Körper. Wenn ein Fehler beim Empfangen der Daten aus der API vorliegt, wird sie in der ERR -Variablen zurückgegeben, sodass wir dies zu Beginn unseres Rückrufs testen.
Andernfalls werden unsere Daten in einer JSON -Zeichenfolge in der Körpervariablen zurückgegeben. Die Körpervariable enthält eine JSON -Zeichenfolge, die so aussieht:
ejs <span>= require('ejs'),</span>Alles, was wir wollen, ist innerhalb von Daten. Wir analysieren die obigen Werte mit JSON.Parse (Körper) in ein JavaScript -Objekt und weisen die Werte im Datenschlüssel einer Variablen mit dem Namen Jawbonedata zu:
:https <span>= require('https'),</span>Dann haben wir eine für Schleife, die jedes Element im Array innerhalb von Daten durchläuft und unsere Datums- und Schlafzeiten formatiert, bevor sie sie in unsere Vorlage zurückgeben, um anzuzeigen.
fs <span>= require('fs'),</span>Hier lesen wir im Datum, konvertieren sie in eine Zeichenfolge und schneiden dann den Tag, den Monat und das Jahr selbst aus. Es wird als Wert von 20150408 zurückgegeben, also schneiden wir die ersten vier Ziffern wie das Jahr heraus, die beiden danach als Monat und die letzten beiden als Tag. Wir ordnen es dann so an, dass es DD/MM/JJJJ wird. Wenn Sie es im US -amerikanischen Datumsformat bevorzugen, können Sie den Monat und den Tag wechseln:
bodyParser <span>= require('body-parser'),</span>Die Jawbone -API gibt einen relativ gut formatierten Schlafdauer -Wert als Titel zurück, der wie folgt aussieht: "für 9H 43M". Wir können dies verwenden, aber das "für" Teil wie SO entfernen:
passport <span>= require('passport'),
</span><span>JawboneStrategy = require('passport-oauth').<span>OAuth2Strategy</span>,</span>Wir geben diese Daten dann an die Rückruffunktion unseres Passes zurück, die unsere userData.ejs rendert. Zu diesem Zweck geben wir unsere Jawbonedata -Variable in die Funktion DEMET zurück. Es gibt auch eine Konsole.log, nur damit wir im Protokoll sehen können, wenn die Daten des Kieferbeins gesendet werden, um angezeigt zu werden:
port <span>= 5000,</span>
Wie ich bereits erwähnt habe, müssen wir unseren Server mit HTTPS ausführen, da der Service von Jawbone, um die Kiefer -API -API zu verwenden, da beide Seiten HTTPS ausführen müssen. Wenn der Callbackurl nicht auf HTTPS eingestellt ist, erhalten Sie "Ungültige Umleitung" -Fehler, wenn Sie versuchen, sich anzumelden.
Um unser Beispiel zum Laufen zu bringen, verwenden wir ein selbst signiertes Zertifikat. Wenn Sie dies auf einer Live -Website tun, möchten Sie von einer gültigen Zertifikatbehörde ordnungsgemäße Zertifikate erhalten.
In server.js haben wir zwei SSL -Optionen definiert:
jawboneAuth <span>= {
</span> <span>clientID: 'jUvu1_4u_mA',
</span> <span>clientSecret: '8961265d16ac678948006c2944ed85dbeeaab547',
</span> <span>authorizationURL: 'https://jawbone.com/auth/oauth2/auth',
</span> <span>tokenURL: 'https://jawbone.com/auth/oauth2/token',
</span> <span>callbackURL: 'https://localhost:5000/sleepdata'
</span><span>},</span>Dies sind die Dateiorte auf unserem Server unserer beiden authentifizierungsbezogenen Dateien:
Um einen privaten Schlüssel zu generieren, müssen wir das OpenSSL -Toolkit verwenden. Mac OSX und Linux-Benutzer sollten dies vorinstalliert haben. Für Windows -Benutzer können Sie Cygwin installieren, auf dem Bildschirm „Pakete auswählen“ nach „OpenSSL“ suchen und das angezeigte Paket auswählen.
Wir können diesen privaten Schlüssel generieren, indem wir unser Terminal öffnen, zum Ordner für unseren Server navigieren und den folgenden Befehl ausführen:
<span>var express = require(‘express’), </span> app <span>= express(),</span>
Dies generiert einen privaten Serverschlüssel, der für die Verwendung von Server bereit ist. Keey.
Wir müssen dann einen CSR erzeugen. Dies würde normalerweise an eine Zertifikatbehörde verschickt, aber in unserem Fall werden wir sie selbst zu Testzwecken selbst unterschreiben.
Um einen CSR mit unserem oben erstellten privaten Schlüssel zu generieren, führen Sie den folgenden Befehl aus:
ejs <span>= require('ejs'),</span>Sie erhalten eine Liste von Fragen, die Sie beantworten können, und erhalten Ihre CSR als Datei namens Server.csr.
Schließlich führen wir den folgenden Befehl aus, um ein selbstsigniertes Zertifikat ohne Zertifikat zu generieren, um ein Zertifikat zu generieren, das für ein Jahr gültig ist:
https <span>= require('https'),</span>Dieser Befehl hätte eine Server.CRT -Datei generieren müssen - dies ist Ihr Zertifikat.
Für diejenigen, die die Dinge ordentlich halten und ihr Zertifikat selbst unterzeichnen, können wir den Server entfernen. CSR, da unser Zertifikat jetzt signiert ist.
Mit unserem privaten Schlüssel und unserem Zertifikat in unserer Knotendatei ist unser Server als HTTPS bereit. Der folgende Code startet den Server mithilfe von HTTPS und unseren SSLOPTIONS:
fs <span>= require('fs'),</span>Unser HTML für diese App ist alles in .ejs -Dateien, damit wir bei Bedarf JavaScript -Variablen in sie einbeziehen können. Diese Dateien befinden sich alle innerhalb /Ansichten. Index.ejs ist sehr einfach und enthält nur einen Titel, Anweisungen und eine Protokoll -Schaltfläche, die zu /login /Jawbone wird:
bodyParser <span>= require('body-parser'),</span>userData.ejs ist, wo die Aktion ist. Das Hauptbit, auf das wir uns konzentrieren können, ist unsere Tabelle:
passport <span>= require('passport'),
</span><span>JawboneStrategy = require('passport-oauth').<span>OAuth2Strategy</span>,</span>Um die App zum Laufen zu bringen, gehen Sie zu Ihrem Terminal und laufen Sie aus:
port <span>= 5000,</span>
Wenn Sie ausgeführt werden, gehen Sie zu http: // localhost: 5000 und Sie sehen unsere Anfangsseite:
Wenn wir auf die Schaltfläche Anmeldung klicken, werden wir zu http: // localhost: 5000/login/Jawbone übertragen, die uns auf die Seite der Kieferbone -Authentifizierung leitet. Die Seite fordert uns für unsere Anmeldedetails für Jawbone auf. Sobald Sie diese Details eingegeben haben oder wenn Sie bereits auf der Jawbone -Website angemeldet sind, werden Sie auf eine Auth -Seite angewiesen, um Zugriff auf Ihre Benutzerdaten zu fordern. Klicken Sie auf "zustimmen":
Wenn wir klicken, sollten wir uns auf die Seite http: // localhost: 5000/sleepData mit einer Tabelle unserer zurückgegebenen Schlafdaten verwandeln:
Und wenn wir auf die Schaltfläche "Anmeldung abmelden" klicken, sollte es uns auszeichnen und uns wieder auf die Startseite umleiten.
, der unseren Überblick über die Grundlagen der Verbindung mit dem Jawbone Up -API und der Rückgabe von Daten an einen Knotenserver vervollständigt.
.In den nächsten Schritten von hier werden eine Datenbank eingerichtet, um die Daten für die zukünftige Verwendung zu speichern, Benutzerkonten für Ihre App zu erstellen und die Datenmenge, die Sie aus der UP -API eingeben Schöne Grafiken!) Und mehr. Kombinieren Sie diese Daten mit einer beliebigen Anzahl anderer APIs da draußen und das Potenzial einiger wirklich ordentlicher Anwendungen ist riesig!
Das obige ist der detaillierte Inhalt vonVerbindung mit dem Jawbone Up API mit Node.js herstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
