Modèle de Backend d'Application de Grand Livre Comptable
Comptabilité en partie double et Balance de Vérification

Points clés

Aperçu

Un produit comptable a besoin d'entrées de grand livre, de comptes, de transactions de journal et de reporting de balance d'essai.

Ce modèle définit le Grand Livre, l'Entrée de Journal, le Compte et la Balance d'Essai avec des fonctionnalités de reporting et des règles de propriété afin que les équipes puissent mettre en œuvre rapidement une précision financière.

Pourquoi construire votre backend de grand livre comptable avec Back4app ?

Back4app vous offre des primitives de grand livre, d'écriture de journal, de compte et de balance de vérification afin que votre équipe puisse se concentrer sur la précision financière et le reporting au lieu de l'infrastructure.

• •Gestion des grands livres et des comptes: La classe de grand livre avec des champs de compte et la classe d'écriture de journal pour la gestion des transactions soutiennent la précision financière.
• •Fonctionnalités de balance de vérification et de reporting: Générez des rapports de balance de vérification et assurez facilement la précision de la comptabilité en partie double.
• •Flexibilité en temps réel + API: Utilisez les capacités de Back4app pour des mises à jour en temps réel tout en gardant REST et GraphQL disponibles pour chaque client.

Construisez et itérez rapidement sur les fonctionnalités comptables avec un seul contrat backend sur toutes les plateformes.

Avantages principaux

Un backend comptable qui vous aide à itérer rapidement sans sacrifier la structure.

Pile technique

Tout est inclus dans ce modèle de backend de grand livre comptable.

Diagramme ER

Modèle de relation d'entité pour le schéma backend du grand livre comptable.

erDiagram
    User ||--o{ Account : "owner"
    Account ||--o{ Transaction : "account"
    Ledger ||--o{ Transaction : "transactions"

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

    Account {
        String objectId PK
        String name
        String type
        Number balance
        Date createdAt
        Date updatedAt
    }

    Transaction {
        String objectId PK
        Pointer account FK
        Number amount
        String type
        Date date
        Date createdAt
        Date updatedAt
    }

    Ledger {
        String objectId PK
        Array transactions
        Date createdAt
        Date updatedAt
    }

Flux d'intégration

Flux d'exécution typique pour l'authentification, la gestion du grand livre, les écritures de journal, les comptes et la balance de vérification.

sequenceDiagram
  participant User
  participant App as Accounting Ledger App
  participant Back4app as Back4app Cloud

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

  User->>App: View accounts
  App->>Back4app: GET /classes/Account
  Back4app-->>App: Account list

  User->>App: Record transaction
  App->>Back4app: POST /classes/Transaction
  Back4app-->>App: Transaction objectId

  User->>App: Generate ledger report
  App->>Back4app: GET /classes/Ledger
  Back4app-->>App: Ledger details

Dictionnaire de données

Référence complète au niveau des champs pour chaque classe dans le schéma du Grand Livre Comptable.

Sécurité et Permissions

Comment la stratégie ACL et CLP sécurise le grand livre, les écritures de journal, les comptes et les rapports.

Schéma (JSON)

Définition brute du schéma JSON prête à copier dans Back4app ou à utiliser comme référence de mise en œuvre.

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Account",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "type": {
          "type": "String",
          "required": true
        },
        "balance": {
          "type": "Number",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Transaction",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "account": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Account"
        },
        "amount": {
          "type": "Number",
          "required": true
        },
        "type": {
          "type": "String",
          "required": true
        },
        "date": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Ledger",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "transactions": {
          "type": "Array",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Terrain de jeu API

Essayez les points de terminaison REST et GraphQL avec le schéma de Grand Livre Comptable. Les réponses utilisent des données fictives et ne nécessitent pas de compte Back4app.

Utilise le même schéma que ce modèle.

Ce que vous obtenez avec chaque technologie

Chaque pile utilise le même schéma de backend de grand livre comptable et les contrats d'API.

Questions fréquentes

Questions courantes sur la création d'un backend de grand livre comptable avec ce modèle.