Modello Backend dell'Editor di Note e Markdown
Organizza Note e Collabora in Tempo Reale

Punti chiave

Panoramica

Un'app per prendere appunti ha bisogno di funzionalità robuste per la collaborazione in tempo reale e l'editing markdown.

Questo modello definisce Utente, Nota e Collaborazione con capacità in tempo reale e controlli di accesso, consentendo ai team di lavorare insieme in modo efficace.

Perché costruire il tuo backend per la gestione delle note con Back4app?

Back4app fornisce primitive essenziali per note, utenti e collaborazione, affinché il tuo team possa concentrarsi sul miglioramento della produttività e della collaborazione piuttosto che sull'infrastruttura backend.

• •Gestione dei documenti e delle note: Modella le note con supporto markdown e gestisci efficacemente la collaborazione degli utenti.
• •Caratteristiche di sicurezza e condivisione robuste: Controlla l'accesso alle note con permessi dettagliati e consenti una collaborazione senza soluzione di continuità.
• •Funzionalità in tempo reale: Abilita la modifica in tempo reale con Live Queries mantenendo il supporto REST e GraphQL per tutti i client.

Costruisci rapidamente e migliora le tue funzionalità di gestione delle note con un backend centralizzato che supporta tutte le piattaforme.

Vantaggi principali

Un backend per la presa di appunti che accelera lo sviluppo senza compromettere la funzionalità.

Stack tecnico

Tutto incluso in questo modello di backend per la gestione delle note.

Diagramma ER

Modello di relazione tra entità per lo schema backend per le note.

erDiagram
    User ||--o{ Note : "owner"
    User ||--o{ AccessLog : "user"
    Note ||--o{ AccessLog : "note"
    Note ||--o{ Tag : "tags"

    User {
        String objectId PK
        String username
        String email
        String password
        String role
        Date createdAt
        Date updatedAt
    }

    Note {
        String objectId PK
        String title
        String content
        Array tags
        Pointer owner FK
        Date createdAt
        Date updatedAt
    }

    Tag {
        String objectId PK
        String name
        Date createdAt
    }

    AccessLog {
        String objectId PK
        Pointer user FK
        Pointer note FK
        Date accessTime
    }

Flusso di integrazione

Flusso di esecuzione tipico per autenticazione, gestione delle note e collaborazione.

sequenceDiagram
  participant User
  participant App as Note-Taking & Markdown Editor App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Create new note
  App->>Back4app: POST /classes/Note
  Back4app-->>App: Note created confirmation

  User->>App: List all notes
  App->>Back4app: GET /classes/Note?order=-createdAt
  Back4app-->>App: List of notes
  
  User->>App: Access a note
  App->>Back4app: GET /classes/Note/noteId
  Back4app-->>App: Note details

  App->>Back4app: Log access
  Back4app-->>App: AccessLog objectId

Dizionario dei dati

Riferimento completo a livello di campo per ogni classe nello schema di annotazione.

Sicurezza e permessi

Come la strategia ACL e CLP protegge utenti, note e collaborazione.

Schema (JSON)

Definizione dello schema JSON grezzo pronta per essere copiata in Back4app o utilizzata come riferimento di implementazione.

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Note",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "content": {
          "type": "String",
          "required": true
        },
        "tags": {
          "type": "Array",
          "required": false
        },
        "owner": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Tag",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AccessLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "note": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Note"
        },
        "accessTime": {
          "type": "Date",
          "required": true
        }
      }
    }
  ]
}

API Playground

Prova gli endpoint REST e GraphQL contro lo schema di annotazione. Le risposte utilizzano dati fittizi e non richiedono un account Back4app.

Utilizza lo stesso schema di questo template.

Cosa ottieni con ogni tecnologia

Ogni stack utilizza lo stesso schema di backend per la presa di appunti e i contratti API.

Domande Frequenti

Domande comuni sulla creazione di un backend per la presa di appunti con questo template.