Quickstarters
Comment construire un backend pour NativeScript ?

47min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour NativeScript en utilisant Back4app, une plateforme open source qui simplifie le développement backend pour les applications mobiles. 
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4app—comme la gestion de base de données, les fonctions Cloud Code, les points de terminaison API REST et GraphQL, l'authentification des utilisateurs et les requêtes en temps réel (Live Queries)—pour créer un backend sécurisé et évolutif pour vos applications NativeScript.
Vous découvrirez également comment Back4app réduit considérablement le temps de configuration par rapport aux configurations manuelles de serveur et de base de données. 
Nous explorerons des mécanismes de sécurité avancés, la planification de tâches avec Cloud Jobs, et l'utilisation de webhooks pour se connecter à des services tiers. 
À la fin de ce guide, vous disposerez d'un backend flexible qui tire parti de NativeScript Core, qui alimente les solutions mobiles multiplateformes de NativeScript.
Avec cette base, vous serez prêt à intégrer votre propre logique personnalisée ou des API externes selon vos besoins. Cela sera une étape majeure vers le développement d'applications NativeScript prêtes pour la production.
Prérequis
Un compte Back4app et un nouveau projet Back4app
Commencer avec Back4app.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Environnement de développement NativeScript de base
Vous pouvez le configurer en utilisant le CLI NativeScript ou un autre flux de travail préféré.
Guide de démarrage de NativeScript.﻿
Node.js (version 14 ou supérieure) installé
Vous aurez besoin de Node.js pour installer des paquets npm et exécuter le CLI NativeScript. Installer Node.js﻿
Familiarité avec JavaScript et NativeScript Core
Documentation officielle de NativeScript.
Si vous êtes nouveau dans NativeScript, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4app configuré et votre environnement local NativeScript prêt vous aidera à suivre plus facilement.
Étape 1 – Configuration du projet Back4app
Créer un nouveau projet
La première étape pour construire votre backend NativeScript sur Back4app consiste à créer un nouveau projet. Si ce n'est pas déjà fait, suivez ces étapes :
Connectez-vous à votre compte Back4app.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4app.
Donnez un nom à votre application (par exemple, “NativeScript-Backend-Tutorial”).
﻿
Après avoir créé le projet, vous le verrez listé dans votre tableau de bord Back4app. Ce projet servira de base pour toutes les configurations backend couvertes dans ce tutoriel.
Connecter le SDK Parse
Back4app utilise la plateforme Parse pour gérer vos données, la fonctionnalité en temps réel, l'authentification des utilisateurs, et plus encore. Pour connecter votre application NativeScript à Back4app, installez le package npm parse et initialisez-le avec les identifiants que vous obtenez de votre tableau de bord Back4app.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4app, allez dans la section “Paramètres de l'application” ou “Sécurité & Clés” de votre application. Recherchez votre ID d'application, Clé JavaScript, et URL du serveur Parse (au format https://parseapi.back4app.com).
﻿
Installer le SDK Parse:
Bash
npm install parse
npm install parse
﻿
Ensuite, initialisez Parse dans un fichier de configuration ou votre fichier d'entrée principal (par exemple, app.js). Par exemple, vous pourriez créer un fichier nommé parseConfig.js dans un projet basé sur NativeScript :
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;
﻿
Chaque fois que vous avez besoin d'accéder à Parse dans votre application NativeScript, importez simplement ce fichier. En complétant cette étape, vous avez établi une connexion sécurisée entre votre frontend NativeScript et le backend Back4app, simplifiant les opérations de données.
Étape 2 – Configuration de la base de données
Sauvegarde et requête de données
Avec votre projet Back4app prêt et le SDK Parse intégré, vous pouvez sauvegarder et interroger des données depuis votre application NativeScript. Voici un exemple utilisant la classe Parse.Object pour sauvegarder et récupérer une liste d'éléments :
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);
  }
}
﻿
Vous pouvez également utiliser l'API REST de Back4app si vous préférez des appels HTTP directs :
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
﻿
Ou utilisez 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
    }
  }
}
﻿
Cette flexibilité rend pratique la création de fonctionnalités backend pour vos applications NativeScript via le SDK Parse, les points de terminaison REST ou GraphQL.
Conception de schéma et types de données
Par défaut, Parse peut automatiquement créer un schéma à la volée, ou vous pouvez définir vos classes et types de données dans le tableau de bord Back4app :
Allez à la section “Base de données” dans votre tableau de bord Back4app.
Créez une nouvelle classe (par exemple, “Tâche”) et ajoutez des colonnes comme titre (String) et isCompleted (Boolean).
Créer une nouvelle classe
﻿
Back4app prend en charge des types de données comme String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, et Polygon. Vous pouvez soit laisser Parse créer ces colonnes lorsque vous enregistrez un objet pour la première fois, soit les définir pour plus de contrôle.
Créer une colonne
﻿
Utiliser l'agent AI de Back4app peut également vous aider à générer automatiquement des schémas :
Ouvrez l'agent AI dans votre tableau de bord d'application.
Décrivez votre modèle de données souhaité (par exemple, “Veuillez créer une nouvelle classe Task pour les applications mobiles avec les champs isCompleted et dueDate.”).
Laissez l'agent créer le schéma automatiquement.
﻿
Données relationnelles
Si vous voulez des données relationnelles—comme un objet Catégorie qui pointe vers plusieurs éléments Task—utilisez des Pointeurs ou des Relations dans 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();
﻿
Cette approche vous aide à récupérer des données complètes pour une Tâche et sa Catégorie associée en une seule requête.
Requêtes en direct
Pour des mises à jour en temps réel, activez les Requêtes en direct dans les Paramètres du serveur dans le tableau de bord de Back4app. Les développeurs NativeScript peuvent s'abonner aux changements dans une classe spécifique. Mettez à jour votre configuration Parse pour inclure une URL de serveur de requête en direct :
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;
﻿
Et ensuite abonnez-vous aux événements en temps réel :
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;
}
﻿
Cette souscription met automatiquement à jour votre interface utilisateur chaque fois qu'une Tâche est ajoutée, modifiée ou supprimée—parfait pour des applications NativeScript collaboratives en direct.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Mécanisme de sécurité Back4app
Back4app incorpore des Listes de Contrôle d'Accès (ACL) et des Permissions au Niveau de la Classe (CLP) pour protéger vos données. Ces modèles de sécurité vous permettent de contrôler l'accès en lecture/écriture à la fois au niveau de la classe et de l'objet.
﻿
Listes de Contrôle d'Accès (ACL)
Une ACL définit les permissions pour chaque objet. Par exemple, pour donner uniquement au propriétaire un accès en lecture et en écriture :
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);
  }
}
﻿
Cela garantit que seul l'utilisateur spécifié peut modifier ou lire l'objet.
Modifier l'ACL
﻿
Permissions au Niveau de la Classe (CLPs)
Les CLPs définissent les permissions par défaut pour toute une classe :
Ouvrir la Base de Données dans Back4app et sélectionner la classe pertinente.
Accéder aux Permissions au Niveau de la Classe onglet.
Ajuster les permissions pour le public, les utilisateurs authentifiés ou des rôles spécifiques selon les besoins.
﻿
La combinaison des ACL et des CLPs offre un modèle de sécurité solide pour les applications NativeScript. Pour plus d'infos, voir Directives de Sécurité de l'Application.
Étape 4 – Écriture et Déploiement des Fonctions Cloud
Le Code Cloud vous permet d'exécuter du code JavaScript personnalisé côté serveur, vous n'avez donc pas besoin de maintenir l'infrastructure vous-même. C'est idéal pour ajouter une logique avancée ou des intégrations réservées au serveur dans votre backend NativeScript.
Comment ça fonctionne
Vous placez généralement votre code Cloud (fonctions JavaScript, déclencheurs et tous les modules NPM requis) dans un main.js fichier. Ensuite, vous le déployez sur Back4app, et il s'exécute dans l'environnement du serveur Parse sans configuration supplémentaire du serveur.
Exemple de structure 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');
  }
});
﻿
Vous pouvez installer et utiliser des packages NPM comme axios pour les requêtes HTTP. Cette approche permet une large gamme d'intégrations, des passerelles de paiement aux API externes, le tout derrière la sécurité de votre application Back4app.
Cas d'utilisation typiques
Logique métier: Calculs automatiques, transformations de données ou mises à jour de statut.
Validations de données: Assurez-vous que les champs requis sont présents avant de sauvegarder.
Déclencheurs: Exécutez du code lorsque des données sont créées, mises à jour ou supprimées.
Intégrations: Connectez-vous à des services externes pour les paiements, l'analyse ou la messagerie.
Application de la sécurité: Validez les données entrantes ou les rôles des utilisateurs avant de continuer.
Déployez votre fonction
Voici une fonction simple qui calcule la longueur du texte :
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 };
});
﻿
Déploiement via Back4app CLI:
Installer le 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
﻿
Pour Windows, téléchargez le b4a.exe fichier depuis la page des versions.
Configurer votre clé de compte:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Déployez votre code cloud:
Bash
b4a deploy
b4a deploy
﻿
Déploiement via le tableau de bord:
Allez à Cloud Code > Functions dans votre tableau de bord.
Collez votre code de fonction dans main.js.
Cliquez sur Déployer.
﻿
Appeler votre fonction
Depuis votre application NativeScript utilisant le SDK Parse :
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);
  }
}
﻿
Vous pouvez également l'appeler en utilisant REST ou GraphQL :
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
  }
}
﻿
Cela vous donne un moyen flexible d'intégrer la logique côté serveur dans vos applications mobiles basées sur NativeScript.
Étape 5 – Configuration de l'authentification des utilisateurs
Authentification des utilisateurs dans Back4app
Back4app utilise la classe Parse User pour gérer l'authentification, ce qui inclut le hachage des mots de passe, les jetons de session, et plus encore. Cela élimine une grande partie de la complexité associée à la gestion des comptes utilisateurs.
Configuration de l'authentification des utilisateurs
Dans votre application NativeScript, vous pouvez créer un nouvel utilisateur :
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);
  }
}
﻿
Un exemple REST pourrait ressembler à :
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
﻿
Gestion des sessions
Après s'être connecté, Parse attribue un jeton de session à l'utilisateur. Pour vérifier l'utilisateur actuellement connecté :
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');
}
﻿
Se déconnecter est simple :
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Intégration de la connexion sociale
Parse s'intègre également avec des fournisseurs OAuth comme Google ou Facebook. La configuration varie selon le fournisseur, donc consultez Se connecter avec Apple et d'autres pour plus de détails. Par exemple, avec 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);
  }
};
﻿
Vérification de l'email et réinitialisation du mot de passe
Activez ces fonctionnalités dans votre tableau de bord Back4app :
Accédez aux paramètres de l'email dans votre application Back4app.
Activez la vérification par email et la réinitialisation du mot de passe.
Configurez vos modèles d'email et l'adresse « De ».
Étape 6 – Gestion du stockage de fichiers
Téléchargement et récupération de fichiers
Back4app prend en charge la gestion des fichiers via la Parse.File classe. Dans NativeScript, vous pouvez télécharger des images ou des documents de manière similaire :
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();
}
﻿
Vous pouvez récupérer l'URL du fichier à partir de l'objet enregistré :
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
﻿
Sécurité des fichiers
Parse Server vous permet de configurer la sécurité du téléchargement de fichiers :
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Cela vous permet de limiter ou d'autoriser les téléchargements de fichiers en fonction de vos préférences de sécurité.
Étape 7 – Planification des tâches avec des travaux cloud
Emplois Cloud
Emplois Cloud vous aident à automatiser des tâches routinières, comme la suppression d'enregistrements obsolètes ou l'envoi de notifications. Par exemple :
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);
  }
});
﻿
Déployez ce travail via CLI ou le tableau de bord.
Dans le Tableau de bord Back4app > Paramètres du serveur > Emplois en arrière-plan, planifiez-le pour qu'il s'exécute quotidiennement ou à un intervalle de votre choix.
Planification d'un emploi Cloud
﻿
Étape 8 – Intégration des Webhooks
Les Webhooks vous permettent d'envoyer des requêtes HTTP à des services externes lorsque certains événements se produisent dans votre application, comme de nouveaux enregistrements ou des inscriptions d'utilisateurs. Cela peut être utilisé pour s'intégrer à Slack, des passerelles de paiement ou des plateformes d'analyse.
Allez à la configuration des Webhooks dans votre tableau de bord Back4app et sélectionnez Ajouter un Webhook.
Ajoutez votre point de terminaison URL (par exemple, https://your-service.com/webhook).
Configurez les déclencheurs pour des classes ou des événements spécifiques.
Ajout d'un Webhook
﻿
Vous pouvez également définir des webhooks dans le code Cloud ou appeler des API externes directement dans des déclencheurs comme beforeSave ou afterSave.
Avant de sauvegarder le WebHook
﻿
Étape 9 – Exploration du panneau d'administration Back4app
L' Application d'administration Back4app est une interface centrée sur le modèle, conviviale pour la gestion des données. Elle aide les équipes ou les utilisateurs non techniques à effectuer des opérations CRUD, à créer des tableaux de bord personnalisés et à gérer des tâches de niveau entreprise sans écrire de code.
Activation de l'application d'administration
Dans votre Tableau de bord de l'application, cliquez sur Plus > Application d'administration.
Activer l'application d'administration.
Activer l'application d'administration
﻿
Créez un premier utilisateur administrateur (nom d'utilisateur/mot de passe). Cette configuration ajoute le rôle B4aAdminUser et les classes associées (B4aSetting, B4aMenuItem, etc.) à votre schéma.
﻿
Choisissez un sous-domaine, puis connectez-vous avec vos nouvelles informations d'identification administratives :
﻿
﻿
Ce portail permet une manipulation rapide des données sans quitter une interface graphique—une excellente solution pour collaborer avec des membres de l'équipe qui pourraient ne pas être familiers avec le codage.
Conclusion
En suivant ce guide, vous avez appris comment construire un backend pour NativeScript en utilisant Back4app et:
Créé un backend sécurisé pour vos applications NativeScript.
Configuré une base de données avec des classes, des schémas et des relations.
Implémenté des requêtes en temps réel pour des mises à jour en direct.
Sécurisé vos données avec des ACL et des CLP.
Étendu la fonctionnalité avec Cloud Code.
Mis en place l'authentification pour l'inscription des utilisateurs, la connexion et les jetons de session.
Géré les téléchargements de fichiers et la récupération via Parse File.
Planifié des Cloud Jobs pour des tâches automatisées et périodiques.
Créé des Webhooks pour des intégrations tierces.
Utilisé le panneau d'administration Back4app pour une gestion des données sans code.
Ces étapes forment une base solide pour construire des applications mobiles open source et multiplateformes avec NativeScript Core. Continuez à explorer des fonctionnalités avancées, incorporez plus de points de terminaison API ou intégrez votre propre logique personnalisée pour adapter le backend aux besoins exacts de votre application.
Prochaines étapes
Évoluez vos applications NativeScript en optimisant les performances, le caching et les règles de sécurité.
Explorez la gestion avancée des utilisateurs comme les permissions basées sur les rôles.
Consultez la documentation officielle de Back4app pour des guides approfondis sur la sécurité, les journaux et les performances.
Expérimentez avec des intégrations du monde réel telles que les paiements ou les outils d'analyse.
Bon codage, et profitez du flux de développement simplifié que Back4app fournit!
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour htmx ?
Comment construire un backend pour ASP.NET Core ?