Quickstarters
Wie man ein Backend für NativeScript erstellt?

47min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für NativeScript mit Back4app erstellt, einer Open-Source-Plattform, die die Backend-Entwicklung für mobile Apps vereinfacht. 
Wir werden die Integration wesentlicher Back4app-Funktionen durchgehen – wie Datenbankverwaltung, Cloud-Code-Funktionen, REST- und GraphQL-API-Endpunkte, Benutzerauthentifizierung und Echtzeitanfragen (Live Queries) – um ein sicheres und skalierbares Backend für Ihre NativeScript-Apps zu erstellen.
Sie werden auch entdecken, wie Back4app die Einrichtungszeit im Vergleich zu manuellen Server- und Datenbankkonfigurationen drastisch reduziert. 
Wir werden fortschrittliche Sicherheitsmechanismen, das Planen von Aufgaben mit Cloud-Jobs und die Verwendung von Webhooks zur Verbindung mit Drittanbieterdiensten erkunden. 
Am Ende dieses Leitfadens haben Sie ein flexibles Backend, das die Vorteile von NativeScript Core nutzt, das die plattformübergreifenden mobilen Lösungen von NativeScript antreibt.
Mit dieser Grundlage sind Sie bereit, Ihre eigene benutzerdefinierte Logik oder externe APIs nach Bedarf zu integrieren. Dies wird ein wichtiger Schritt zur Entwicklung produktionsbereiter NativeScript-Apps sein.
Voraussetzungen
Ein Back4app-Konto und ein neues Back4app-Projekt
Erste Schritte mit Back4app.
Wenn Sie kein Konto haben, können Sie eines kostenlos erstellen. Folgen Sie dem obigen Leitfaden, um Ihr Projekt vorzubereiten.
Grundlegende NativeScript-Entwicklungsumgebung
Sie können dies mit der NativeScript CLI oder einem anderen bevorzugten Workflow einrichten.
NativeScript Erste Schritte Anleitung.﻿
Node.js (Version 14 oder höher) installiert
Sie benötigen Node.js, um npm-Pakete zu installieren und die NativeScript CLI auszuführen. Node.js installieren﻿
Vertrautheit mit JavaScript und NativeScript Core
Offizielle Dokumentation von NativeScript.
Wenn Sie neu bei NativeScript sind, lesen Sie die offiziellen Dokumente oder ein Tutorial für Anfänger, bevor Sie beginnen.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Ihr Back4app-Projekt eingerichtet und Ihre lokale NativeScript-Umgebung bereit zu haben, wird Ihnen helfen, leichter folgen zu können.
Schritt 1 – Einrichten des Back4app-Projekts
Ein neues Projekt erstellen
Der erste Schritt beim Erstellen Ihres NativeScript-Backends auf Back4app besteht darin, ein neues Projekt zu erstellen. Wenn Sie dies noch nicht getan haben, folgen Sie diesen Schritten:
Melden Sie sich bei Ihrem Back4app-Konto an.
Klicken Sie auf die Schaltfläche „Neue App“ in Ihrem Back4app-Dashboard.
Geben Sie Ihrer App einen Namen (z. B. „NativeScript-Backend-Tutorial“).
﻿
Nachdem Sie das Projekt erstellt haben, wird es in Ihrem Back4app-Dashboard aufgeführt. Dieses Projekt dient als Grundlage für alle Backend-Konfigurationen, die in diesem Tutorial behandelt werden.
Verbinden Sie das Parse SDK
Back4app verwendet die Parse-Plattform, um Ihre Daten, Echtzeitfunktionen, Benutzerauthentifizierung und mehr zu verwalten. Um Ihre NativeScript-App mit Back4app zu verbinden, installieren Sie das parse npm-Paket und initialisieren Sie es mit den Anmeldeinformationen, die Sie von Ihrem Back4app-Dashboard erhalten.
Holen Sie sich Ihre Parse-Schlüssel:
Gehen Sie in Ihrem Back4app-Dashboard zum Abschnitt „App-Einstellungen“ oder „Sicherheit & Schlüssel“ Ihrer App. Suchen Sie nach Ihrer Anwendungs-ID, JavaScript-Schlüssel, und Parse-Server-URL (im Format https://parseapi.back4app.com).
﻿
Installieren Sie das Parse SDK:
Bash
npm install parse
npm install parse
﻿
Dann, initialisieren Sie Parse in einer Konfigurationsdatei oder Ihrer Hauptdatei (z.B. app.js). Zum Beispiel könnten Sie eine Datei namens parseConfig.js in einem NativeScript-basierten Projekt erstellen:
src/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
﻿
Wann immer Sie in Ihrer NativeScript-App auf Parse zugreifen müssen, importieren Sie einfach diese Datei. Durch diesen Schritt haben Sie eine sichere Verbindung zwischen Ihrem NativeScript-Frontend und dem Back4app-Backend hergestellt, was die Datenoperationen vereinfacht.
Schritt 2 – Datenbank einrichten
Daten speichern und abfragen
Mit Ihrem Back4app-Projekt bereit und dem Parse SDK integriert, können Sie Daten aus Ihrer NativeScript-App speichern und abfragen. Unten finden Sie ein Beispiel, das die Parse.Object-Klasse verwendet, um eine Liste von Elementen zu speichern und abzurufen:
JS
// Example: Create a Task item
import Parse from './parseConfig';

async function createTaskItem(title, isCompleted) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);
  task.set('isCompleted', isCompleted);

  try {
    const savedTask = await task.save();
    console.log('Task saved successfully:', savedTask);
    return savedTask;
  } catch (error) {
    console.error('Error saving Task:', error);
  }
}

// Example: Query all Task items
async function fetchTasks() {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  try {
    const results = await query.find();
    console.log('Fetched Task items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Tasks:', error);
  }
}
// Example: Create a Task item
import Parse from './parseConfig';

async function createTaskItem(title, isCompleted) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);
  task.set('isCompleted', isCompleted);

  try {
    const savedTask = await task.save();
    console.log('Task saved successfully:', savedTask);
    return savedTask;
  } catch (error) {
    console.error('Error saving Task:', error);
  }
}

// Example: Query all Task items
async function fetchTasks() {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  try {
    const results = await query.find();
    console.log('Fetched Task items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Tasks:', error);
  }
}
﻿
Sie können auch die REST-API von Back4app verwenden, wenn Sie direkte HTTP-Anfragen bevorzugen:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy supplies", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Task
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy supplies", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Task
﻿
Oder verwende GraphQL:
GraphQL
mutation {
  createTask(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    task {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTask(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    task {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Diese Flexibilität macht es bequem, Backend-Funktionen für deine NativeScript-Apps über die Parse SDK, REST oder GraphQL API-Endpunkte zu erstellen.
Schema-Design und Datentypen
Standardmäßig kann Parse automatisch Schema on the fly erstellen, oder du kannst deine Klassen und Datentypen im Back4app-Dashboard definieren:
Gehe zum Abschnitt „Datenbank“ in deinem Back4app-Dashboard.
Erstelle eine neue Klasse (z.B. „Aufgabe“) und füge Spalten wie Titel (String) und isCompleted (Boolean) hinzu.
Neue Klasse erstellen
﻿
Back4app unterstützt Datentypen wie String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, und Polygon. Du kannst entweder Parse diese Spalten erstellen lassen, wenn du ein Objekt zum ersten Mal speicherst, oder sie für mehr Kontrolle definieren.
Spalte erstellen
﻿
Die Verwendung des AI-Agenten von Back4app kann Ihnen auch helfen, Schemas automatisch zu generieren:
Öffnen Sie den AI-Agenten in Ihrem App-Dashboard.
Beschreiben Sie Ihr gewünschtes Datenmodell (z.B. „Bitte erstellen Sie eine neue Aufgabenklasse für mobile Apps mit den Feldern isCompleted und dueDate.“).
Lassen Sie den Agenten das Schema automatisch erstellen.
﻿
Relationale Daten
Wenn Sie relationale Daten möchten—wie ein Kategorie Objekt, das auf mehrere Aufgaben verweist—verwenden Sie Zeiger oder Beziehungen in Parse:
JS
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const task = new Parse.Object('Task');
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  task.set('title', title);
  task.set('category', categoryPointer);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}

// Including the pointer data in a query
const query = new Parse.Query('Task');
query.include('category');
const tasksWithCategory = await query.find();
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const task = new Parse.Object('Task');
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  task.set('title', title);
  task.set('category', categoryPointer);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}

// Including the pointer data in a query
const query = new Parse.Query('Task');
query.include('category');
const tasksWithCategory = await query.find();
﻿
Dieser Ansatz hilft Ihnen, vollständige Daten für eine Aufgabe und ihre zugehörige Kategorie in einer einzigen Abfrage abzurufen.
Echtzeitabfragen
Für Echtzeit-Updates aktivieren Sie Echtzeitabfragen unter Servereinstellungen im Back4app-Dashboard. NativeScript-Entwickler können Änderungen in einer bestimmten Klasse abonnieren. Aktualisieren Sie Ihre Parse-Konfiguration, um eine URL für den Live-Query-Server einzuschließen:
src/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
﻿
Und dann abonnieren Sie Echtzeitereignisse:
JS
import Parse from './parseConfig';

async function subscribeToTasks(callback) {
  const query = new Parse.Query('Task');
  const subscription = await query.subscribe();

  subscription.on('create', (newTask) => {
    console.log('New Task created:', newTask);
    callback('create', newTask);
  });

  subscription.on('update', (updatedTask) => {
    console.log('Task updated:', updatedTask);
    callback('update', updatedTask);
  });

  subscription.on('delete', (deletedTask) => {
    console.log('Task deleted:', deletedTask);
    callback('delete', deletedTask);
  });

  return subscription;
}
import Parse from './parseConfig';

async function subscribeToTasks(callback) {
  const query = new Parse.Query('Task');
  const subscription = await query.subscribe();

  subscription.on('create', (newTask) => {
    console.log('New Task created:', newTask);
    callback('create', newTask);
  });

  subscription.on('update', (updatedTask) => {
    console.log('Task updated:', updatedTask);
    callback('update', updatedTask);
  });

  subscription.on('delete', (deletedTask) => {
    console.log('Task deleted:', deletedTask);
    callback('delete', deletedTask);
  });

  return subscription;
}
﻿
Dieses Abonnement aktualisiert automatisch Ihre Benutzeroberfläche, wann immer eine Aufgabe hinzugefügt, geändert oder entfernt wird – perfekt für Live-Zusammenarbeit in NativeScript-Apps.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Back4app Sicherheitsmechanismus
Back4app integriert Zugriffskontrolllisten (ACLs) und Klassenebene Berechtigungen (CLPs) zum Schutz Ihrer Daten. Diese Sicherheitsmodelle ermöglichen es Ihnen, den Lese-/Schreibzugriff sowohl auf Klassen- als auch auf Objektebene zu steuern.
﻿
Zugriffskontrolllisten (ACLs)
Eine ACL legt Berechtigungen für jedes Objekt fest. Zum Beispiel, um nur dem Eigentümer Lese- und Schreibzugriff zu gewähren:
JS
async function createPrivateTask(title, ownerUser) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);

  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);
  task.setACL(acl);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error saving private task:', err);
  }
}
async function createPrivateTask(title, ownerUser) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);

  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);
  task.setACL(acl);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error saving private task:', err);
  }
}
﻿
Dies stellt sicher, dass nur der angegebene Benutzer das Objekt ändern oder lesen kann.
ACL bearbeiten
﻿
Klassenebene Berechtigungen (CLPs)
CLPs legen die Standardberechtigungen für eine gesamte Klasse fest:
Öffnen Sie die Datenbank in Back4app und wählen Sie die relevante Klasse aus.
Zugriff auf die Klassenebene Berechtigungen Registerkarte.
Passen Sie die Berechtigungen für die Öffentlichkeit, authentifizierte Benutzer oder spezifische Rollen nach Bedarf an.
﻿
Die Kombination von ACLs und CLPs bietet ein starkes Sicherheitsmodell für NativeScript-Apps. Für weitere Informationen siehe App-Sicherheitsrichtlinien.
Schritt 4 – Schreiben und Bereitstellen von Cloud-Funktionen
Cloud Code ermöglicht es Ihnen, benutzerdefinierten JavaScript-Code auf der Serverseite auszuführen, sodass Sie die Infrastruktur nicht selbst warten müssen. Dies ist ideal, um erweiterte Logik oder serverseitige Integrationen in Ihrem NativeScript-Backend hinzuzufügen.
Wie es funktioniert
Sie platzieren typischerweise Ihren Cloud-Code (JavaScript-Funktionen, Trigger und alle erforderlichen NPM-Module) in einer main.js-Datei. Dann stellen Sie es bei Back4app bereit, und es läuft in der Parse-Server-Umgebung ohne zusätzliche Serverkonfiguration.
Beispiel für die Struktur von main.js:
JS
const axios = require('axios');

Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

Parse.Cloud.beforeSave('Task', (request) => {
  const task = request.object;
  if (!task.get('title')) {
    throw new Error('Task must have a title');
  }
});
const axios = require('axios');

Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

Parse.Cloud.beforeSave('Task', (request) => {
  const task = request.object;
  if (!task.get('title')) {
    throw new Error('Task must have a title');
  }
});
﻿
Sie können NPM-Pakete wie axios für HTTP-Anfragen installieren und verwenden. Dieser Ansatz ermöglicht eine Vielzahl von Integrationen, von Zahlungs-Gateways bis hin zu externen APIs, alles hinter der Sicherheit Ihrer Back4app-App.
Typische Anwendungsfälle
Geschäftslogik: Automatische Berechnungen, Datenumwandlungen oder Statusaktualisierungen.
Datenvalidierungen: Sicherstellen, dass erforderliche Felder vor dem Speichern vorhanden sind.
Trigger: Code ausführen, wenn Daten erstellt, aktualisiert oder gelöscht werden.
Integrationen: Verbindung zu externen Diensten für Zahlungen, Analysen oder Messaging.
Sicherheitsdurchsetzung: Eingehende Daten oder Benutzerrollen validieren, bevor Sie fortfahren.
Ihre Funktion bereitstellen
Hier ist eine einfache Funktion, die die Textlänge berechnet:
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Bereitstellung über Back4app CLI:
Installieren Sie die CLI:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Für Windows, laden Sie die b4a.exe Datei von der Release-Seite.
Konfigurieren Sie Ihren Kontoschlüssel:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Bereitstellen Sie Ihren Cloud-Code:
Bash
b4a deploy
b4a deploy
﻿
Bereitstellung über das Dashboard:
Gehe zu Cloud Code > Funktionen in deinem Dashboard.
Füge deinen Funktionscode in main.js ein.
Klicke auf Bereitstellen.
﻿
Rufe deine Funktion auf
Von deiner NativeScript-App aus mit dem Parse SDK:
JS
import Parse from './parseConfig';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
import Parse from './parseConfig';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
﻿
Du kannst es auch mit REST oder GraphQL aufrufen:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
﻿
GraphQL
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
﻿
Dies gibt dir eine flexible Möglichkeit, serverseitige Logik in deine auf NativeScript basierenden mobilen Apps zu integrieren.
Schritt 5 – Konfiguration der Benutzerauthentifizierung
Benutzerauthentifizierung in Back4app
Back4app verwendet die Parse User-Klasse zur Handhabung der Authentifizierung, die Passwort-Hashing, Sitzungstoken und mehr umfasst. Dies beseitigt einen Großteil der Komplexität, die mit der Verwaltung von Benutzerkonten verbunden ist.
Einrichten der Benutzerauthentifizierung
In Ihrer NativeScript-App können Sie einen neuen Benutzer erstellen:
JS
import Parse from './parseConfig';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
import Parse from './parseConfig';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
﻿
Ein REST-Beispiel könnte so aussehen:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Sitzungsverwaltung
Nach dem Einloggen weist Parse dem Benutzer ein Sitzungstoken zu. Um den aktuell eingeloggenen Benutzer zu überprüfen:
JS
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
﻿
JS
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
﻿
Das Abmelden ist einfach:
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Integration von sozialem Login
Parse integriert sich auch mit OAuth-Anbietern wie Google oder Facebook. Die Einrichtung variiert je nach Anbieter, siehe Anmelden mit Apple und anderen für Details. Zum Beispiel mit Facebook:
JS
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
﻿
E-Mail-Verifizierung und Passwortzurücksetzung
Aktivieren Sie diese Funktionen in Ihrem Back4app-Dashboard:
Navigieren Sie zu den E-Mail-Einstellungen in Ihrer Back4app-App.
E-Mail-Verifizierung aktivieren und Passwortzurücksetzung.
Konfigurieren Sie Ihre E-Mail-Vorlagen und die „Von“-Adresse.
Schritt 6 – Umgang mit Dateispeicher
Hochladen und Abrufen von Dateien
Back4app unterstützt die Dateiverwaltung über die Parse.File Klasse. In NativeScript können Sie Bilder oder Dokumente ähnlich hochladen:
JS
import Parse from './parseConfig';

async function uploadImage(file) {
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
import Parse from './parseConfig';

async function uploadImage(file) {
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
﻿
Sie können die URL der Datei aus dem gespeicherten Objekt abrufen:
JS
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
// Use imageUrl in your NativeScript UI components
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
// Use imageUrl in your NativeScript UI components
﻿
Dateisicherheit
Parse Server ermöglicht es Ihnen, die Sicherheit beim Hochladen von Dateien zu konfigurieren:
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Dies stellt sicher, dass Sie Datei-Uploads basierend auf Ihren Sicherheitspräferenzen einschränken oder zulassen können.
Schritt 7 – Aufgaben mit Cloud-Jobs planen
Cloud Jobs
Cloud Jobs helfen Ihnen, Routineaufgaben zu automatisieren, wie das Entfernen veralteter Datensätze oder das Senden von Benachrichtigungen. Zum Beispiel:
JS
// main.js
Parse.Cloud.job('cleanupOldTasks', async (request) => {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTasks = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTasks, { useMasterKey: true });
    return `Deleted ${oldTasks.length} old Tasks.`;
  } catch (err) {
    throw new Error('Cleanup error:' + err.message);
  }
});
// main.js
Parse.Cloud.job('cleanupOldTasks', async (request) => {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTasks = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTasks, { useMasterKey: true });
    return `Deleted ${oldTasks.length} old Tasks.`;
  } catch (err) {
    throw new Error('Cleanup error:' + err.message);
  }
});
﻿
Bereitstellen dieses Jobs über die CLI oder das Dashboard.
Im Back4app Dashboard > Servereinstellungen > Hintergrundjobs, planen Sie es, täglich oder in einem von Ihnen gewählten Intervall auszuführen.
Planung eines Cloud-Jobs
﻿
Schritt 8 – Integration von Webhooks
Webhooks ermöglichen es Ihnen, HTTP-Anfragen an externe Dienste zu senden, wenn bestimmte Ereignisse in Ihrer App auftreten – wie neue Datensätze oder Benutzeranmeldungen. Dies kann verwendet werden, um mit Slack, Zahlungs-Gateways oder Analyseplattformen zu integrieren.
Gehen Sie zur Webhook-Konfiguration in Ihrem Back4app-Dashboard und wählen Sie Webhook hinzufügen.
Fügen Sie Ihre Endpunkt-URL hinzu (z. B. https://your-service.com/webhook).
Konfigurieren Sie Trigger für bestimmte Klassen oder Ereignisse.
Hinzufügen eines Webhooks
﻿
Sie können auch Webhooks im Cloud-Code definieren oder externe APIs direkt in Triggern wie beforeSave oder afterSave aufrufen.
BeforeSave WebHook
﻿
Schritt 9 – Erkundung des Back4app Admin Panels
Die Back4app Admin App ist eine modellzentrierte, benutzerfreundliche Schnittstelle für das Datenmanagement. Sie hilft Teams oder nicht-technischen Benutzern, CRUD-Operationen durchzuführen, benutzerdefinierte Dashboards zu erstellen und unternehmensweite Aufgaben ohne Programmierung zu verwalten.
Aktivierung der Admin App
In Ihrem App Dashboard, klicken Sie auf Mehr > Admin App.
Admin App aktivieren.
Admin App aktivieren
﻿
Erstellen Sie einen ersten Admin-Benutzer (Benutzername/Passwort). Diese Einrichtung fügt die B4aAdminUser Rolle und zugehörige Klassen (B4aSetting, B4aMenuItem, usw.) zu Ihrem Schema hinzu.
﻿
Wählen Sie eine Subdomain und melden Sie sich mit Ihren neuen Admin-Anmeldeinformationen an:
﻿
﻿
Dieses Portal ermöglicht eine schnelle Datenmanipulation, ohne die grafische Benutzeroberfläche zu verlassen – eine großartige Lösung für die Zusammenarbeit mit Teammitgliedern, die möglicherweise nicht mit Programmierung vertraut sind.
Fazit
Indem Sie diesem Leitfaden folgen, haben Sie gelernt wie man ein Backend für NativeScript erstellt mit Back4app und:
Ein sicheres Backend erstellt für Ihre NativeScript-Apps.
Eine Datenbank konfiguriert mit Klassen, Schemata und Beziehungen.
Echtzeitabfragen implementiert für Live-Updates.
Ihre Daten gesichert mit ACLs und CLPs.
Die Funktionalität mit Cloud Code erweitert.
Die Authentifizierung eingerichtet für Benutzeranmeldung, Login und Sitzungstoken.
Datei-Uploads verwaltet und Abruf über Parse File.
Cloud-Jobs geplant für automatisierte, regelmäßige Aufgaben.
Webhooks erstellt für Integrationen von Drittanbietern.
Das Back4app Admin Panel verwendet für codefreie Datenverwaltung.
Diese Schritte bilden eine robuste Grundlage für den Aufbau von Open-Source, plattformübergreifenden mobilen Apps mit NativeScript Core. Setzen Sie die Erkundung fort, integrieren Sie erweiterte Funktionen, fügen Sie weitere API-Endpunkte hinzu oder integrieren Sie Ihre eigene benutzerdefinierte Logik, um das Backend genau auf die Bedürfnisse Ihrer App abzustimmen.
Nächste Schritte
Skalieren Sie Ihre NativeScript-Apps durch Optimierung der Leistung, Caching und Sicherheitsregeln.
Erforschen Sie das erweiterte Benutzermanagement wie rollenbasierte Berechtigungen.
Sehen Sie sich die offizielle Back4app-Dokumentation an für umfassende Anleitungen zu Sicherheit, Protokollen und Leistung.
Experimentieren Sie mit realen Integrationen wie Zahlungen oder Analysetools.
Viel Spaß beim Programmieren und genießen Sie den optimierten Entwicklungsworkflow, den Back4app bietet!
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für htmx erstellt?
ALS NÄCHSTES
Wie man ein Backend für ASP.NET Core erstellt?