Quickstarters
Come costruire un backend per MacOS?

45min
Introduzione
In questo tutorial, imparerai come costruire un backend per MacOS utilizzando Back4app e il Parse Swift SDK. 
Esploreremo l'integrazione delle funzionalità essenziali di Back4app—come la gestione del database, le Funzioni Cloud Code, le API REST e GraphQL, l'autenticazione degli utenti e le query in tempo reale (Live Queries)—per creare un backend sicuro, scalabile e robusto che comunica senza problemi con la tua applicazione MacOS.
Vedrai anche come la rapida configurazione di Back4app e l'ambiente intuitivo possano ridurre drasticamente il tempo e lo sforzo rispetto alla configurazione manuale di server e database. 
Lungo il percorso, acquisirai esperienza pratica con funzionalità chiave, inclusi avanzati strumenti di sicurezza, pianificazione di attività con Cloud Jobs e configurazione di webhook per integrazioni esterne.
Entro la fine di questo tutorial, sarai ben preparato per migliorare questa configurazione fondamentale in un'applicazione macOS pronta per la produzione, o per incorporare facilmente logica personalizzata e API di terze parti secondo necessità.
Padroneggiare questo approccio ti permetterà di semplificare i tuoi flussi di lavoro e imparare a costruire un backend per MacOS rapidamente ed efficientemente.
Requisiti
Per completare questo tutorial, avrai bisogno di:
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.
Un ambiente di sviluppo MacOS (Xcode)
Puoi installare Xcode dal Mac App Store.
Swift Package Manager o CocoaPods
Per installare il Parse Swift SDK. Documentazione di Parse Swift.﻿
Conoscenze di base di Swift e sviluppo di app macOS
Documentazione ufficiale di Apple
Familiarità con SwiftUI o AppKit è utile.
Assicurati di avere tutti questi requisiti in ordine prima di iniziare. Avere il tuo progetto Back4app impostato e il tuo ambiente di sviluppo macOS locale 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 macOS su Back4app è creare un nuovo progetto. Se non ne hai già creato uno, 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, “macOS-Backend-Tutorial”).
﻿
Una volta creato il progetto, lo vedrai elencato nel tuo dashboard di Back4app. Questo progetto sarà la base per tutte le configurazioni del backend discusse in questo tutorial.
Collegare il Parse Swift SDK
Back4app si basa sulla Parse Platform per gestire i tuoi dati, fornire funzionalità in tempo reale, gestire l'autenticazione degli utenti e altro ancora. Collegare la tua applicazione macOS a Back4app implica installare il Parse Swift SDK e inizializzarlo con le credenziali 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 per trovare il tuo ID Applicazione e Chiave Client (o clientKey). Troverai anche l' URL del Server Parse (spesso nel formato https://parseapi.back4app.com).
﻿
Installa il Parse Swift SDK nel tuo progetto macOS:
Se utilizzi Swift Package Manager:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Se utilizzi CocoaPods, aggiungi questo al tuo Podfile:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Inizializza Parse nella tua applicazione macOS (ad esempio, in AppDelegate.swift se utilizzi AppKit, o in una @main struct se stai costruendo un'app SwiftUI):
Swift
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Completando questo passaggio, hai stabilito una connessione sicura tra il tuo front-end macOS (UI) e il backend di Back4app. Tutte le richieste e le transazioni di dati vengono instradate in modo sicuro attraverso questo SDK, riducendo la complessità delle chiamate REST o GraphQL manuali (anche se puoi comunque utilizzarle se necessario).
Passo 2 – Configurazione del Database
Salvataggio e Query dei Dati
Con il tuo progetto Back4app configurato e il Parse Swift SDK integrato nella tua app macOS, puoi ora iniziare a salvare e recuperare dati. Il modo più semplice per creare un oggetto è definire una struct che conforma a ParseObject e poi chiamare save():
Swift
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
﻿
In alternativa, puoi utilizzare l'API REST o GraphQL di Back4app:
Curl
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 groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
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 groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Back4app fornisce anche un'interfaccia GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Queste diverse opzioni ti consentono di integrare le operazioni sui dati nel modo che meglio si adatta al tuo processo di sviluppo, sia attraverso il Parse Swift SDK, REST o GraphQL.
Progettazione dello Schema e Tipi di Dati
Per impostazione predefinita, Parse consente la creazione di schemi al volo, ma puoi anche definire le tue classi e tipi di dati nel dashboard di Back4app per avere maggiore controllo.
Naviga nella sezione “Database” nel tuo dashboard di Back4app.
Crea una nuova classe (ad esempio, “Todo”) e aggiungi colonne pertinenti, come titolo (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Back4app supporta vari tipi di dati: String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, e Polygon. Puoi scegliere il tipo appropriato per ciascun campo, oppure lasciare che Parse crei automaticamente queste colonne quando salvi per la prima volta un oggetto dalla tua app macOS.
Crea Colonna
﻿
Back4app offre un Agente AI che può aiutarti a progettare il tuo modello di dati:
Apri l'Agente AI dal tuo Dashboard App o dal menu.
Descrivi il tuo modello di dati in linguaggio semplice (ad esempio, “Per favore, crea una nuova App ToDo su back4app con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo Schema per te.
﻿
Dati Relazionali
Se hai dati relazionali—diciamo, un Category oggetto che punta a più Todo elementi—puoi usare Pointers o Relations in Parse Swift:
Swift
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
﻿
Query in tempo reale
Per aggiornamenti in tempo reale, Back4app fornisce Live Queries. Abilitando le Live Queries nel tuo dashboard di Back4app, puoi iscriverti ai cambiamenti in una classe specifica dalla tua app macOS.
Abilita le Live Queries nel tuo dashboard di Back4app sotto le Impostazioni del server della tua app.
Inizializza le Live Queries nel codice (il client Live Query di Swift è ancora in evoluzione, ma puoi utilizzare approcci guidati dalla comunità o aspettare aggiornamenti ufficiali di Parse Swift).
src/parseConfig.swift
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
﻿
Una volta iscritti, riceverai notifiche ogni volta che un nuovo Todo viene creato, aggiornato o eliminato. Questo è particolarmente prezioso per app desktop collaborative o altamente interattive in cui più utenti o processi devono vedere i dati più recenti istantaneamente.
Passo 3 – Applicare la sicurezza con ACL e CLP
Meccanismo di sicurezza di Back4app
Back4app prende sul serio la sicurezza fornendo Access Control Lists (ACLs) e Class-Level Permissions (CLPs). Queste funzionalità ti consentono di limitare chi può leggere o scrivere dati su base per oggetto o per classe, garantendo che solo gli utenti autorizzati possano modificare i tuoi dati.
﻿
Access Control Lists (ACLs)
Un ACL è applicato a singoli oggetti per determinare quali utenti, ruoli o il pubblico possono eseguire operazioni di lettura/scrittura. Ad esempio, se la tua app macOS ha un concetto di “compiti privati” per l'utente attualmente connesso:
Swift
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
﻿
Quando salvi l'oggetto, ha un ACL che impedisce a chiunque tranne l'utente specificato di leggerlo o modificarlo.
Modifica ACL
﻿
Class-Level Permissions (CLPs)
I CLPs governano le autorizzazioni predefinite di un'intera classe, come se la classe sia leggibile o scrivibile pubblicamente, o se solo determinati ruoli possano accedervi.
Vai al tuo Dashboard di Back4app, seleziona la tua app e apri la Database sezione.
Seleziona una classe (ad esempio, “Todo”).
Apri le autorizzazioni a livello di classe tab.
Configura le tue impostazioni predefinite, come “Richiede autenticazione” per la lettura o la scrittura, o “Nessun accesso” per il pubblico.
﻿
Passo 4 – Scrivere e Distribuire Funzioni Cloud
Il Cloud Code è una funzionalità dell'ambiente Parse Server che consente di eseguire codice JavaScript personalizzato sul lato server, senza la necessità di gestire i propri server o infrastrutture. Scrivendo Cloud Code, puoi estendere il tuo backend di Back4app con logica aziendale aggiuntiva, validazioni, trigger e integrazioni che vengono eseguite in modo sicuro ed efficiente sul Parse Server.
Come Funziona
Quando scrivi Cloud Code, di solito posizioni le tue funzioni JavaScript, trigger e eventuali moduli NPM richiesti in un main.js file. Poi distribuisci questo file al tuo progetto Back4app, e viene eseguito nell'ambiente Parse Server. Questo ti consente di mantenere la logica sensibile sul lato server.
Casi d'uso tipici:
Logica Aziendale: Calcoli o trasformazioni prima di salvare i dati
Validazioni dei Dati: Assicurati che determinati campi soddisfino i criteri
Trigger: Esegui azioni quando i dati cambiano
Integrazioni: Collega con API esterne (ad esempio, pagamenti, notifiche)
Esempio di Funzione
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Distribuzione tramite il 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
﻿
Configura la tua chiave account:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Distribuisci il tuo codice cloud:
Bash
b4a deploy
b4a deploy
﻿
Chiamare la tua funzione
Da macOS utilizzando Swift:
Swift
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
﻿
Puoi anche chiamarlo tramite REST o GraphQL, allo stesso modo di altri framework.
Passo 5 – Configurazione dell'autenticazione utente
Autenticazione utente in Back4app
Back4app sfrutta la ParseUser classe come base per l'autenticazione. Per impostazione predefinita, Parse gestisce l'hashing delle password, i token di sessione e lo storage sicuro, quindi non devi configurare manualmente flussi di sicurezza complessi.
Impostazione dell'autenticazione utente
In un'applicazione macOS, puoi creare un nuovo utente con:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
﻿
Via REST, un accesso 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 della sessione
Dopo un accesso riuscito, Parse crea un token di sessione. Puoi accedere all'utente attualmente connesso:
Swift
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
﻿
Disconnettersi:
Swift
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
﻿
Integrazione del login sociale
Puoi integrare provider popolari come Google, Apple o Facebook configurando authData. Le istruzioni dettagliate variano, quindi fai riferimento a Documentazione sul login sociale.﻿
Verifica dell'email e reimpostazione della password
Per abilitare la verifica dell'email e il ripristino della password:
Naviga alle Impostazioni Email nel tuo dashboard di Back4app.
Abilita la verifica dell'email.
Configura l'indirizzo del mittente, i modelli email e il tuo dominio personalizzato se desiderato.
Questo migliora la sicurezza dell'account convalidando le email degli utenti e fornendo un metodo di recupero della password.
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero dei File
Parse include la ParseFile classe per gestire i caricamenti di file, che Back4app memorizza in modo sicuro:
Swift
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
﻿
Allegalo a un oggetto:
Swift
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
﻿
Sicurezza dei file
Puoi configurare la sicurezza del caricamento dei file nelle impostazioni del tuo Parse Server. Ad esempio, controllando quali utenti possono caricare o eliminare file. Tieni presente che se condividi l'URL del file, chiunque abbia quell'URL può accedervi a meno che tu non abbia impostato regole più severe lato server.
Passo 7 – Verifica Email e Ripristino Password
Panoramica
La verifica dell'email e il ripristino delle password sono fondamentali per una gestione sicura degli utenti. Ne abbiamo già parlato nel Passo 5, ma come promemoria:
Abilita queste funzionalità nel Back4app Dashboard (Impostazioni Email).
Configura i modelli di email per “Abilita Verifica Email” e “Ripristino Password”.
Testa il flusso dalla tua app macOS.
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
Cloud Jobs ti consente di pianificare ed eseguire compiti di routine sul tuo backend, come inviare email periodiche o pulire i dati. Ad esempio:
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Distribuisci il tuo Cloud Code con il nuovo lavoro.
Vai al Dashboard di Back4app > Impostazioni App > Impostazioni Server > Lavori in Background.
Pianifica il lavoro (ad esempio, quotidianamente).
Pianificazione di un lavoro Cloud
﻿
Passo 9 – Integrazione dei Webhook
I Webhook consentono alla tua app Back4app di inviare richieste HTTP a un servizio esterno ogni volta che si verificano determinati eventi. Questo è potente per l'integrazione con sistemi di terze parti come gateway di pagamento, strumenti di email marketing o piattaforme di analisi.
Naviga nella configurazione dei Webhook nel tuo dashboard di Back4app > Altro > WebHooks.
Imposta un endpoint (ad esempio, https://your-external-service.com/webhook-endpoint).
Configura i trigger per specificare quali eventi nelle tue classi Back4app o nelle funzioni Cloud Code attiveranno il webhook.
Aggiunta di un Webhook
﻿
Ad esempio, se vuoi notificare Slack ogni volta che viene creato un nuovo Todo:
Crea un'app Slack che accetta webhook in entrata.
Copia l'URL del webhook di Slack.
Nel tuo dashboard di Back4app, imposta l'endpoint su quell'URL Slack per l'evento “Nuovo record nella classe Todo.”
Passo 10 – Esplorare il Pannello di Amministrazione di Back4app
Il Back4app Admin App è un'interfaccia di gestione basata sul web progettata per utenti non tecnici per eseguire operazioni CRUD e gestire attività di dati di routine senza scrivere codice. Fornisce un' interfaccia incentrata sul modello, facile da usare che semplifica l'amministrazione del database, la gestione dei dati personalizzati e le operazioni a livello aziendale.
Abilitare l'Admin App
Abilita andando su App Dashboard > Altro > Admin App e cliccando su “Abilita Admin App.”
Abilita Admin App
﻿
Crea un Primo Utente Admin, che genera automaticamente un nuovo ruolo (B4aAdminUser) e classi pertinenti nello schema della tua app.
﻿
Scegli un Sottodominio per accedere all'interfaccia admin e completare la configurazione.
﻿
Accedi utilizzando le credenziali admin che hai creato per accedere al tuo nuovo dashboard dell'Admin App.
﻿
Una volta abilitata, l'app Back4app Admin rende facile visualizzare, modificare o rimuovere record dal tuo database, senza richiedere l'uso diretto del Parse Dashboard o del codice backend.
Conclusione
Seguendo questo tutorial completo, hai:
Creato un backend sicuro per un'app macOS su Back4app.
Configurato un database con schemi di classe, tipi di dati e relazioni.
Integrato query in tempo reale (Live Queries) per aggiornamenti immediati dei dati.
Applicato misure di sicurezza utilizzando ACL e CLP per proteggere e gestire l'accesso ai dati.
Implementato funzioni di Cloud Code per eseguire logica aziendale personalizzata sul lato server.
Impostato l'autenticazione degli utenti con supporto per la verifica dell'email e il ripristino della password.
Gestito caricamenti di file e recupero, con controlli di sicurezza dei file opzionali.
Pianificato Cloud Jobs per attività di background automatizzate.
Utilizzato Webhooks per integrarsi con servizi esterni.
Esplorato il pannello di amministrazione di Back4app per la gestione dei dati.
Con un solido front-end macOS e un robusto backend Back4app, sei ora ben attrezzato per sviluppare applicazioni desktop ricche di funzionalità, scalabili e sicure. Continua a esplorare funzionalità più avanzate, integra la tua logica aziendale e sfrutta la potenza di Back4app per risparmiarti innumerevoli ore nella gestione di server e database.
Prossimi Passi
Costruisci un'app macOS pronta per la produzione estendendo questo backend per gestire modelli di dati più complessi, strategie di caching e ottimizzazioni delle prestazioni.
Integra funzionalità avanzate come flussi di autenticazione specializzati, controllo degli accessi basato sui ruoli o API esterne (come i gateway di pagamento).
Controlla la documentazione ufficiale di Back4app per approfondimenti su sicurezza avanzata, ottimizzazione delle prestazioni e analisi dei log.
Esplora altri tutorial su comunicazione in tempo reale, dashboard IoT o servizi basati sulla posizione. Combina le tecniche apprese qui con API di terze parti per creare applicazioni complesse e reali.
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per tvOS?
AVANTI IL PROSSIMO
Come costruire un backend per iOS?