Quickstarters
Come costruire un backend per NativeScript?

49min
Introduzione
In questo tutorial, imparerai come costruire un backend per NativeScript utilizzando Back4app, una piattaforma open source che semplifica lo sviluppo del backend per le app mobili. 
Esploreremo l'integrazione delle funzionalità essenziali di Back4app—come la gestione del database, le Funzioni Cloud Code, gli endpoint API REST e GraphQL, l'autenticazione degli utenti e le query in tempo reale (Live Queries)—per creare un backend sicuro e scalabile per le tue app NativeScript.
Scoprirai anche come Back4app riduce drasticamente i tempi di configurazione rispetto alle configurazioni manuali di server e database. 
Esploreremo meccanismi di sicurezza avanzati, la pianificazione di attività con Cloud Jobs e l'uso di webhook per connettersi a servizi di terze parti. 
Entro la fine di questa guida, avrai un backend flessibile che sfrutta NativeScript Core, che alimenta le soluzioni mobili cross-platform di NativeScript.
Con questa base, sarai pronto a integrare la tua logica personalizzata o API esterne secondo necessità. Questo sarà un passo importante verso lo sviluppo di app NativeScript pronte per la produzione.
Requisiti
Un account Back4app e un nuovo progetto Back4app
Iniziare con Back4app.
Se non hai un account, puoi crearne uno gratuitamente. Segui la guida sopra per preparare il tuo progetto.
Ambiente di sviluppo NativeScript di base
Puoi configurarlo utilizzando il NativeScript CLI o un altro flusso di lavoro preferito.
Guida per iniziare con NativeScript.﻿
Node.js (versione 14 o superiore) installato
Avrai bisogno di Node.js per installare pacchetti npm e eseguire il NativeScript CLI. Installare Node.js﻿
Familiarità con JavaScript e NativeScript Core
Documentazione ufficiale di NativeScript.
Se sei nuovo a NativeScript, rivedi la documentazione ufficiale o un tutorial per principianti prima di iniziare.
Assicurati di avere tutti questi requisiti in atto prima di iniziare. Avere il tuo progetto Back4app configurato e il tuo ambiente locale NativeScript pronto ti aiuterà a seguire più facilmente.
Passo 1 – Configurazione del Progetto Back4app
Crea un Nuovo Progetto
Il primo passo per costruire il tuo backend NativeScript su Back4app è creare un nuovo progetto. Se non lo hai già fatto, segui questi passaggi:
Accedi al tuo account Back4app.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4app.
Dai un nome alla tua app (ad esempio, “NativeScript-Backend-Tutorial”).
﻿
Dopo aver creato il progetto, lo vedrai elencato nel tuo dashboard di Back4app. Questo progetto servirà come base per tutte le configurazioni del backend trattate in questo tutorial.
Collegare il Parse SDK
Back4app utilizza la Parse Platform per gestire i tuoi dati, la funzionalità in tempo reale, l'autenticazione degli utenti e altro ancora. Per collegare la tua app NativeScript a Back4app, installa il parse pacchetto npm e inizializzalo con le credenziali che ottieni dal tuo dashboard di Back4app.
Recupera le tue Chiavi Parse:
Nel tuo dashboard di Back4app, vai alla sezione “Impostazioni App” o “Sicurezza e Chiavi” della tua app. Cerca il tuo ID Applicazione, Chiave JavaScript, e URL del Server Parse (nel formato https://parseapi.back4app.com).
﻿
Installa il Parse SDK:
Bash
npm install parse
npm install parse
﻿
Poi, inizializza Parse in un file di configurazione o nel tuo file di ingresso principale (ad esempio, app.js). Ad esempio, potresti creare un file chiamato parseConfig.js in un progetto basato su 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;
﻿
Ogni volta che hai bisogno di accedere a Parse nella tua app NativeScript, basta importare questo file. Completando questo passaggio, hai stabilito una connessione sicura tra il tuo frontend NativeScript e il backend Back4app, semplificando le operazioni sui dati.
Passo 2 – Configurazione del Database
Salvataggio e Query dei Dati
Con il tuo progetto Back4app pronto e il Parse SDK integrato, puoi salvare e interrogare i dati dalla tua app NativeScript. Di seguito è riportato un esempio che utilizza la classe Parse.Object per salvare e recuperare un elenco di elementi:
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);
  }
}
﻿
Puoi anche utilizzare l'API REST di Back4app se preferisci chiamate HTTP dirette:
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
﻿
Oppure usa 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
    }
  }
}
﻿
Questa flessibilità rende conveniente costruire funzionalità backend per le tue app NativeScript attraverso il Parse SDK, REST o gli endpoint API GraphQL.
Progettazione dello schema e tipi di dati
Per impostazione predefinita, Parse può creare automaticamente schemi al volo, oppure puoi definire le tue classi e tipi di dati nel dashboard di Back4app:
Vai alla sezione “Database” nel tuo dashboard di Back4app.
Crea una nuova classe (ad esempio, “Task”) e aggiungi colonne come titolo (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Back4app supporta tipi di dati come String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, e Polygon. Puoi lasciare che Parse crei queste colonne quando salvi per la prima volta un oggetto o definirle per avere maggiore controllo.
Crea Colonna
﻿
Utilizzare l'AI Agent di Back4app può anche aiutarti a generare automaticamente schemi:
Apri l'AI Agent nel tuo App Dashboard.
Descrivi il tuo modello di dati desiderato (ad es., “Per favore crea una nuova classe Task per app mobili con i campi isCompleted e dueDate.”).
Lascia che l'agente crei lo schema automaticamente.
﻿
Dati Relazionali
Se desideri dati relazionali—come un oggetto Categoria che punta a più Task—usa Puntatori o Relazioni 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();
﻿
Questo approccio ti aiuta a recuperare dati completi per un Task e la sua Categoria correlata in un'unica query.
Query Live
Per aggiornamenti in tempo reale, abilita Query Live nelle Impostazioni del Server nel dashboard di Back4app. Gli sviluppatori di NativeScript possono iscriversi a modifiche in una classe specifica. Aggiorna la tua configurazione Parse per includere un URL del server Live Query:
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;
﻿
E poi iscriviti agli eventi in tempo reale:
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;
}
﻿
Questa iscrizione aggiorna automaticamente la tua interfaccia utente ogni volta che una Task viene aggiunta, modificata o rimossa—perfetta per app NativeScript collaborative in tempo reale.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Meccanismo di Sicurezza Back4app
Back4app incorpora Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP) per proteggere i tuoi dati. Questi modelli di sicurezza ti consentono di controllare l'accesso in lettura/scrittura sia a livello di classe che di oggetto.
﻿
Liste di Controllo degli Accessi (ACL)
Un ACL imposta i permessi per ogni oggetto. Ad esempio, per dare solo al proprietario accesso in lettura e scrittura:
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);
  }
}
﻿
Questo garantisce che solo l'utente specificato possa modificare o leggere l'oggetto.
Modifica ACL
﻿
Permessi a Livello di Classe (CLP)
I CLP impostano i permessi predefiniti per un'intera classe:
Apri il Database in Back4app e seleziona la classe pertinente.
Accedi ai Permessi a Livello di Classe.
Regola i permessi per il pubblico, gli utenti autenticati o ruoli specifici secondo necessità.
﻿
Combinare ACL e CLP offre un modello di sicurezza robusto per le app NativeScript. Per ulteriori informazioni, vedere Linee Guida sulla Sicurezza delle App.
Passo 4 – Scrivere e Distribuire Funzioni Cloud
Il Cloud Code ti consente di eseguire codice JavaScript personalizzato sul lato server, quindi non è necessario mantenere l'infrastruttura da solo. Questo è ideale per aggiungere logica avanzata o integrazioni solo server nel tuo backend NativeScript.
Come Funziona
Di solito posizioni il tuo Cloud Code (funzioni JavaScript, trigger e eventuali moduli NPM richiesti) in un main.js file. Poi lo distribuisci su Back4app e viene eseguito nell'ambiente del Parse Server senza configurazione aggiuntiva del server.
Esempio di Struttura 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');
  }
});
﻿
Puoi installare e utilizzare pacchetti NPM come axios per le richieste HTTP. Questo approccio consente una vasta gamma di integrazioni, dai gateway di pagamento alle API esterne, tutto dietro la sicurezza della tua app Back4app.
Casi d'Uso Tipici
Logica Aziendale: Calcoli automatici, trasformazioni di dati o aggiornamenti di stato.
Validazioni dei Dati: Assicurati che i campi richiesti siano presenti prima del salvataggio.
Trigger: Esegui codice quando i dati vengono creati, aggiornati o eliminati.
Integrazioni: Collega servizi esterni per pagamenti, analisi o messaggistica.
Applicazione della Sicurezza: Valida i dati in arrivo o i ruoli degli utenti prima di procedere.
Distribuisci la Tua Funzione
Ecco una funzione semplice che calcola la lunghezza del testo:
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 };
});
﻿
Distribuzione tramite Back4app CLI:
Installa il 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
﻿
Per Windows, scarica il b4a.exe file dalla pagina delle versioni.
Configura la tua chiave account:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Distribuisci il tuo codice cloud:
Bash
b4a deploy
b4a deploy
﻿
Distribuzione tramite il Dashboard:
Vai a Cloud Code > Functions nel tuo dashboard.
Incolla il tuo codice funzione in main.js.
Clicca su Deploy.
﻿
Chiamare la tua funzione
Dalla tua app NativeScript utilizzando il 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);
  }
}
﻿
Puoi anche chiamarlo utilizzando REST o 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
  }
}
﻿
Questo ti offre un modo flessibile per integrare la logica lato server nelle tue app mobili basate su NativeScript.
Passo 5 – Configurazione dell'autenticazione utente
Autenticazione Utente in Back4app
Back4app utilizza la classe Parse User per gestire l'autenticazione, che include l'hashing delle password, i token di sessione e altro ancora. Questo elimina gran parte della complessità associata alla gestione degli account utente.
Impostazione dell'Autenticazione Utente
Nella tua app NativeScript, puoi creare un nuovo utente:
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 esempio REST potrebbe apparire così:
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
﻿
Gestione delle Sessioni
Dopo aver effettuato il login, Parse assegna un token di sessione all'utente. Per controllare l'utente attualmente connesso:
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');
}
﻿
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');
}
﻿
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');
}
﻿
Disconnettersi è semplice:
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Integrazione del Login Sociale
Parse si integra anche con fornitori OAuth come Google o Facebook. La configurazione varia a seconda del fornitore, quindi consulta Accedi con Apple e Altri per i dettagli. Ad esempio, con 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);
  }
};
﻿
Verifica Email e Ripristino Password
Abilita queste funzionalità nel tuo dashboard di Back4app:
Naviga su Impostazioni Email nella tua app Back4app.
Abilita la verifica email e il ripristino della password. 
Configura i tuoi modelli email e l'indirizzo 'Da'.
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero di File
Back4app supporta la gestione dei file attraverso la Parse.File classe. In NativeScript, puoi caricare immagini o documenti in modo simile:
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();
}
﻿
Puoi recuperare l'URL del file dall'oggetto salvato:
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
﻿
Sicurezza dei File
Parse Server ti consente di configurare la sicurezza del caricamento dei file:
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Questo assicura che tu possa limitare o consentire i caricamenti di file in base alle tue preferenze di sicurezza.
Passo 7 – Pianificazione di Compiti con Cloud Jobs
Lavori nel Cloud
Lavori nel Cloud ti aiutano ad automatizzare compiti di routine, come rimuovere record obsoleti o inviare notifiche. Ad esempio:
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);
  }
});
﻿
Distribuisci questo lavoro tramite CLI o il dashboard.
Nel Dashboard di Back4app > Impostazioni del server > Lavori in background, programmarlo per essere eseguito quotidianamente o a un intervallo di tua scelta.
Pianificazione di un lavoro nel Cloud
﻿
Passo 8 – Integrazione dei Webhook
Webhook ti consentono di inviare richieste HTTP a servizi esterni quando si verificano determinati eventi nella tua app, come nuovi record o registrazioni di utenti. Questo può essere utilizzato per integrarsi con Slack, gateway di pagamento o piattaforme di analisi.
Vai alla configurazione dei Webhook nel tuo dashboard di Back4app e seleziona Aggiungi Webhook.
Aggiungi il tuo endpoint URL (ad es., https://your-service.com/webhook).
Configura i trigger per classi o eventi specifici.
Aggiunta di un Webhook
﻿
Puoi anche definire webhook nel Cloud Code o chiamare API esterne direttamente nei trigger come beforeSave o afterSave.
BeforeSave WebHook
﻿
Passo 9 – Esplorare il Pannello di Amministrazione di Back4app
L' App di Amministrazione di Back4app è un'interfaccia centrata sul modello e facile da usare per la gestione dei dati. Aiuta i team o gli utenti non tecnici a eseguire operazioni CRUD, creare dashboard personalizzate e gestire compiti a livello aziendale senza scrivere codice.
Abilitare l'App di Amministrazione
Nel tuo Dashboard dell'App, clicca su Altro > App di Amministrazione.
Abilita l'App di Amministrazione.
Abilita l'App di Amministrazione
﻿
Crea un primo utente amministratore (nome utente/password). Questa configurazione aggiunge il B4aAdminUser ruolo e le classi associate (B4aSetting, B4aMenuItem, ecc.) al tuo schema.
﻿
Scegli un sottodominio, quindi accedi con le tue nuove credenziali di amministratore:
﻿
﻿
Questo portale consente una rapida manipolazione dei dati senza lasciare un'interfaccia grafica—una grande soluzione per collaborare con membri del team che potrebbero non essere familiari con la programmazione.
Conclusione
Seguendo questa guida, hai imparato come costruire un backend per NativeScript utilizzando Back4app e:
Creato un backend sicuro per le tue app NativeScript.
Configurato un database con classi, schemi e relazioni.
Implementato query in tempo reale per aggiornamenti live.
Protetto i tuoi dati con ACL e CLP.
Esteso la funzionalità con Cloud Code.
Impostato l'autenticazione per la registrazione, il login e i token di sessione.
Gestito il caricamento di file e il recupero tramite Parse File.
Pianificato Cloud Jobs per compiti automatizzati e periodici.
Creato Webhook per integrazioni di terze parti.
Utilizzato il Pannello di Amministrazione di Back4app per la gestione dei dati senza codice.
Questi passaggi formano una base solida per costruire app mobili open source e multipiattaforma con NativeScript Core. Continua a esplorare funzionalità avanzate, incorpora più endpoint API o integra la tua logica personalizzata per adattare il backend alle esigenze esatte della tua app.
Prossimi Passi
Scala le tue app NativeScript ottimizzando le prestazioni, la memorizzazione nella cache e le regole di sicurezza.
Esplora la gestione avanzata degli utenti come le autorizzazioni basate sui ruoli.
Controlla la documentazione ufficiale di Back4app per guide dettagliate su sicurezza, registri e prestazioni.
Sperimenta con integrazioni del mondo reale come strumenti di pagamento o di analisi.
Buon coding e goditi il flusso di lavoro di sviluppo semplificato che Back4app offre!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per htmx?
AVANTI IL PROSSIMO
Come creare un backend per ASP.NET Core?