Journal d'importation/exportation Backend

Modèle de journal d'importation/exportation Backend
Codes HTS, journaux des droits et historique des entrées douanières

Q: Quels contrôles de journaux d'importation/exportation sont les plus importants lorsque les opérations s'étendent sur plusieurs sites ?

C'est un schéma backend et une API pour le suivi des codes HTS, des journaux de droits, des déclarations douanières et de l'historique des expéditions à travers les flux de travail d'importation et d'exportation.

Q: Quelles relations entre Shipment, HTSCode et DutyLog facilitent la narration des audits de journaux d'importation/exportation ?

Il comprend Shipment, HTSCode, DutyLog, CustomsEntry et AuditNote, ainsi qu'un diagramme ER, un espace de jeu API et une invite d'agent AI.

Q: Pouvons-nous ajouter une notation de risque de journal d'importation/exportation ou des files d'attente d'exception sans une refonte ?

Back4app vous offre une base de données gérée, une authentification, des requêtes en temps réel et un schéma flexible afin que les responsables et les coordinateurs puissent suivre les expéditions, les droits et l'historique douanier sans gérer leur propre backend.

Q: Comment interroger les expéditions et les journaux de droits dans Flutter ?

Utilisez les classes Shipment et DutyLog pour charger les entrées d'importation/exportation actuelles, puis affichez htsCode, dutyAmount et releaseStatus dans l'interface utilisateur.

Q: Comment gérer l'accès aux journaux d'importation/exportation avec Next.js Server Actions ?

Utilisez une action serveur pour créer un objet Parse Shipment ou DutyLog avec des pointeurs d'utilisateur, puis validez les droits d'édition dans Cloud Code.

Q: Est-ce que React peut mettre en cache les déclarations en douane hors ligne ?

Oui. Activez le Local Datastore et épinglez les résultats de Shipment et CustomsEntry afin que les utilisateurs puissent consulter les journaux sauvegardés sans connexion.

Q: Comment puis-je empêcher les modifications non autorisées des codes HTS ?

Dans Cloud Code avantSave pour HTSCode, appliquez des vérifications de rôle et rejetez les mises à jour des utilisateurs qui ne sont pas autorisés à maintenir les classifications.

Q: Quelle est la meilleure façon d'afficher l'historique des déclarations en douane sur Android ?

Interrogez les classes CustomsEntry et Shipment pour afficher les dates de dépôt, les courtiers et le releaseStatus, en utilisant le SDK Back4app pour l'accès aux données.

Q: Comment fonctionne le workflow du registre des droits de douane de bout en bout ?

Un coordinateur sélectionne un envoi, lie le code HTS correct, enregistre DutyLog.dutyAmount, puis met à jour CustomsEntry.releaseStatus lorsque l'entrée est dédouanée.

Un backend de journal d'importation/exportation prêt pour la production sur Back4app avec codes HTS, journaux des droits et historique des entrées douanières. Comprend un diagramme ER, un dictionnaire de données, un schéma JSON, un espace de jeu API, et un prompt Agent IA pour une configuration rapide.

Construire avec Agent IA Choisissez votre technologie

Principaux enseignements pour les opérations logistiques

Ce modèle vous offre un backend de journal d'import/export avec des codes HTS, des journaux des droits et un historique des entrées douanières afin que le personnel opérationnel puisse examiner les entrées et les expéditions à un seul endroit.

Suivi des codes HTS — Stockez les lignes de HTSCode avec des numéros de tarif, des descriptions et des notes de classification spécifiques au pays.
Historique des journaux des droits — Conservez les entrées des journaux des droits liées aux expéditions, aux numéros d'entrée et aux montants évalués.
Historique des entrées douanières — Examinez les enregistrements d'entrée par port, courtier, date de dépôt et statut de libération.
Visibilité des expéditions — Lier les classes d'expédition et de déclaration en douane afin que le personnel puisse suivre chaque importation ou exportation depuis le dépôt jusqu'à la dédouanement.

Aperçu : Journal d'importation/exportation

Dans le journal d'importation/exportation, « nous le faisons généralement de cette façon » n'est pas un contrôle — les étapes documentées et les résultats capturés le sont. Sur Back4app, Expédition, HTSCode, Journal des droits, Déclaration en douane et Note d'audit se connectent dans un récit cohérent du journal d'importation/exportation au lieu d'un amoncellement de tickets et de fichiers déconnectés. Le schéma couvre l'Expédition (shipmentNo, direction, port d'origine, port de destination), HTSCode (code, description, taux de droits), Journal des droits (expédition, htsCode, montant des droits, évalué par), Déclaration en douane (entryNo, courtier, déposé à, statut de libération) et Note d'audit (entrée, note, auteur) avec accès basé sur l'authentification et les rôles intégrés. Connectez votre frontend et commencez à enregistrer les activités douanières plus rapidement.

Meilleur pour :

Équipes d'opérations d'importation/exportationOutils de suivi des déclarations en douaneTableaux de bord de calcul des droitsRépertoires de classification HTSPortails de courtier et de coordinateurÉquipes choisissant BaaS pour les flux de travail logistiques

Comment ce backend de journal d'import/export est organisé

Les équipes mobiles et le personnel de back-office voient différentes tranches de réalité dans le journal d'import/export ; le travail du produit consiste à assembler ces tranches sans jeux de responsabilité.

Examinez d'abord l'expédition, HTSCode et DutyLog, puis ouvrez une carte d'empilement pour voir les notes spécifiques au SDK et les modèles d'intégration.

Fonctions principales du journal d'importation/exportation

Chaque carte de technologie dans ce hub utilise le même schéma de journal d'importation/exportation avec Shipment, HTSCode, DutyLog, CustomsEntry et AuditNote.

Suivi de l'expédition

L'expédition stocke shipmentNo, direction, originPort, destinationPort et status.

Bibliothèque de code HTS

HTSCode conserve les champs code, description, chapitre et dutyRate.

Entrées de registre des droits

DutyLog relie l'expédition, le htsCode, le montant des droits et la personne ayant évalué.

Historique des entrées douanières

CustomsEntry capture entryNo, broker, filedAt et releaseStatus.

Pourquoi construire votre backend de journal d'import/export avec Back4app ?

Back4app fournit à votre équipe des primitives d'expédition, de droits et d'entrée afin que l'accent reste mis sur la classification et le travail de dépôt plutôt que sur les tâches d'infrastructure.

•Expédition et données de dépôt dans un seul modèle: Les classes Shipment et CustomsEntry maintiennent originPort, destinationPort, entryNo et releaseStatus ensemble.
•Visibilité des droits et HTS: Les champs HTSCode et DutyLog tels que code, dutyRate, dutyAmount et assessedBy supportent les tâches de révision et d'audit.
•Mises à jour de journal en temps réel: Utilisez Live Queries pour observer les changements de CustomsEntry tout en gardant REST et GraphQL disponibles pour les outils d'expédition et de reporting.

Construisez un backend de journal qui fournit aux gestionnaires et coordonnateurs l'historique des expéditions dont ils ont besoin sans retravailler le schéma plus tard.

Avantages principaux

Un backend de journal d'importation/exportation qui aide les équipes à examiner les dépôts plus rapidement et à conserver les détails des expéditions au même endroit.

Examen de classification plus rapide

Utilisez HTSCode.code et HTSCode.dutyRate pour comparer les articles sans fouiller dans des feuilles de calcul.

Effacer les traces de devoir

DutyLog.dutyAmount et DutyLog.assessedBy conservent qui a calculé chaque montant de devoir.

Historique d'entrée plus clair

CustomsEntry.entryNo, filedAt, et releaseStatus facilitent la réponse aux questions sur le statut depuis le bureau ou l'entrepôt.

Contexte au niveau de l'expédition

Shipment.shipmentNo et Shipment.direction gardent les enregistrements d'importation et d'exportation regroupés par route.

Notes adaptées à l'audit

AuditNote.note et AuditNote.author ajoutent des commentaires de réviseur à des entrées spécifiques lorsque les courtiers ou les gestionnaires demandent un contexte.

Démarrage assisté par IA

Générez le schéma, les règles de sécurité et le flux d'API de démarrage avec une invite structurée.

Prêt à lancer votre application de journal d'import/export ?

Laissez l'agent IA de Back4app générer votre backend de journal d'import/export et créer des workflows d'expédition, de droits et de déclarations en douane à partir d'une seule invite.

Construire avec l'agent IA Essayez le terrain de jeu API

Gratuit pour commencer — 50 invites d'agent IA/mois, aucune carte de crédit requise

Stack technique

Tout inclus dans ce modèle de backend de journal d'import/export.

Frontend

13+ technologies

Backend

Back4app

Base de données

MongoDB

Auth

Authentification intégrée + sessions

API

REST et GraphQL

Temps réel

Live Queries

Diagramme ER d'expédition et de douanes

Modèle de relation d'entité pour le schéma de backend du journal d'import/export.

Diagramme ER

Voir la source du diagramme

Mermaid

erDiagram
    User ||--o{ ImportBatch : "manager"
    User ||--o{ DutyEntry : "enteredBy"
    User ||--o{ CustomsHistory : "recordedBy"
    ImportBatch ||--o{ DutyEntry : "importBatch"
    ImportBatch ||--o{ CustomsHistory : "importBatch"

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

    ImportBatch {
        String objectId PK
        String batchNumber
        String direction
        String status
        String portOfEntry
        String managerId FK
        Date createdAt
        Date updatedAt
    }

    DutyEntry {
        String objectId PK
        String importBatchId FK
        String htsCode
        String goodsDescription
        String countryOfOrigin
        Number declaredValue
        Number dutyAmount
        String enteredById FK
        Date createdAt
        Date updatedAt
    }

    CustomsHistory {
        String objectId PK
        String importBatchId FK
        String entryStatus
        String entryNumber
        Date recordedAt
        String recordedById FK
        Date createdAt
        Date updatedAt
    }

    HtsCodeCatalog {
        String objectId PK
        String htsCode
        String description
        Number dutyRate
        Date effectiveDate
        Date createdAt
        Date updatedAt
    }

Flux d'intégration douanière

Flux d'exécution typique pour la connexion, la recherche d'expédition, l'enregistrement des droits et les mises à jour des déclarations douanières.

Diagramme ER

Voir la source du diagramme

Mermaid

sequenceDiagram
  participant User
  participant App as Import/Export Log App
  participant Back4app as Back4app Cloud

  User->>App: Sign in
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Open import batches
  App->>Back4app: GET /classes/ImportBatch?include=manager
  Back4app-->>App: Batch list

  User->>App: Add duty entry with HTS code
  App->>Back4app: POST /classes/DutyEntry
  Back4app-->>App: DutyEntry objectId

  User->>App: Record customs history
  App->>Back4app: POST /classes/CustomsHistory
  Back4app-->>App: CustomsHistory objectId

  App->>Back4app: GET /classes/HtsCodeCatalog?order=htsCode
  Back4app-->>App: HTS code catalog

Dictionnaire des données de journal

Référence au niveau des champs pour chaque classe dans le schéma du journal d'importation/exportation.

Champ	Type	Description	Requis
objectId	String	Auto-generated unique identifier	Auto
username	String	User login name
email	String	User email address
password	String	Hashed password (write-only)
role	String	Role of the user (e.g. manager, coordinator, field_staff)
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

7 champs dans User

Sécurité et autorisations

Comment les ACL et CLP protègent les expéditions, les codes HTS, les journaux de droits, les déclarations en douane et les notes de révision.

Accès au journal basé sur les rôles

Seuls les gestionnaires, les coordinateurs et le personnel approuvé peuvent modifier les lignes d'expédition, de DutyLog et de CustomsEntry.

Maintenance HTS contrôlée

Les entrées HTSCode ne doivent être accessibles en écriture qu'aux utilisateurs qui maintiennent les classifications ou approuvent les modifications tarifaires.

Protection de la trace d'audit

Utilisez des règles Cloud Code afin que les changements de AuditNote et DutyLog soient validés avant d'être sauvegardés.

Schéma (JSON)

Définition du schéma JSON brute prête à être copiée dans Back4app ou utilisée comme référence d'implémentation.

JSON

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

{
  "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": "ImportBatch",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "batchNumber": {
          "type": "String",
          "required": true
        },
        "direction": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "portOfEntry": {
          "type": "String",
          "required": true
        },
        "manager": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "DutyEntry",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "importBatch": {
          "type": "Pointer",
          "required": true,
          "targetClass": "ImportBatch"
        },
        "htsCode": {
          "type": "String",
          "required": true
        },
        "goodsDescription": {
          "type": "String",
          "required": true
        },
        "countryOfOrigin": {
          "type": "String",
          "required": true
        },
        "declaredValue": {
          "type": "Number",
          "required": true
        },
        "dutyAmount": {
          "type": "Number",
          "required": true
        },
        "enteredBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "CustomsHistory",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "importBatch": {
          "type": "Pointer",
          "required": true,
          "targetClass": "ImportBatch"
        },
        "entryStatus": {
          "type": "String",
          "required": true
        },
        "entryNumber": {
          "type": "String",
          "required": true
        },
        "recordedAt": {
          "type": "Date",
          "required": true
        },
        "recordedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "HtsCodeCatalog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "htsCode": {
          "type": "String",
          "required": true
        },
        "description": {
          "type": "String",
          "required": true
        },
        "dutyRate": {
          "type": "Number",
          "required": true
        },
        "effectiveDate": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construire avec l'Agent IA

Utilisez l'Agent IA Back4app pour générer une véritable application de journal d'import/export à partir de ce modèle, y compris les flux de frontend, backend, authentification, ainsi que d'expédition, de droits et d'entrées douanières.

Agent IA Back4app

Prêt à construire

Créez un backend d'application de journal d'import/export sur Back4app avec ce schéma et ce comportement exact.

Schéma :
1. Utilisateur (utilisez Back4app intégré) : nom d'utilisateur, email, mot de passe ; objectId, createdAt, updatedAt (système).
2. Expédition : shipmentNo (String, requis), direction (String, requis), port d'origine (String, requis), port de destination (String, requis), statut (String, requis) ; objectId, createdAt, updatedAt (système).
3. Code HTS : code (String, requis), description (String, requis), chapitre (String, requis), taux de droit (Number, requis) ; objectId, createdAt, updatedAt (système).
4. Journal des droits : expédition (Pointeur vers Expédition, requis), htsCode (Pointeur vers HTSCode, requis), montant des droits (Number, requis), évalué par (Pointeur vers Utilisateur, requis), évalué à (Date, requis) ; objectId, createdAt, updatedAt (système).
5. Entrée douanière : expédition (Pointeur vers Expédition, requis), entryNo (String, requis), courtier (String, requis), déposé à (Date, requis), statut de libération (String, requis) ; objectId, createdAt, updatedAt (système).
6. Note d’audit : entrée (Pointeur vers Entrée douanière, requis), note (String, requis), auteur (Pointeur vers Utilisateur, requis), créé àNote (Date, requis) ; objectId, createdAt, updatedAt (système).

Sécurité :
- Seuls les gestionnaires et coordinateurs autorisés peuvent modifier les expéditions, les journaux de droits et les entrées douanières. Utilisez le Cloud Code pour la validation.

Auth :
- Inscription, connexion, déconnexion.

Comportement :
- Lister les expéditions, classer les codes HTS, ajouter des journaux de droits, mettre à jour les entrées douanières et joindre des notes d'audit.

Livrer :
- Application Back4app avec schéma, ACL, CLP ; frontend pour les expéditions, les codes HTS, les journaux de droits, les entrées douanières et les notes.

Appuyez sur le bouton ci-dessous pour ouvrir l'Agent avec cette invite de modèle pré-remplie.

Voici l'invite de base sans suffixe technologique. Vous pouvez adapter la pile frontend générée par la suite.

Déployer en quelques minutes50 invites gratuites / moisAucune carte de crédit requise

API Playground

Essayez les points de terminaison REST et GraphQL contre le schéma de journal d'importation/exportation. Les réponses utilisent des données fictives et ne nécessitent pas de compte Back4app.

Chargement du terrain de jeu…

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

Choisissez votre technologie

Développez chaque carte pour voir comment intégrer Shipment, HTSCode et DutyLog avec votre pile choisie.

Ce que vous obtenez avec chaque technologie

Chaque pile utilise le même schéma de journal d'importation/exportation et les contrats API.

Structure de journal d'expédition unifiée pour journal d'import/export

Gérez l'expédition, le HTSCode, le DutyLog, l'entrée en douane et l'AuditNote avec un seul modèle de données.

Flux de travail HTS et de droits pour journal d'import/export

Classifiez les marchandises, stockez les calculs de droits et conservez l'historique de dépôt associé à chaque entrée.

Historique des entrées en douane pour journal d'import/export

Examinez les numéros d'entrée, les courtiers, les dates de dépôt et le statut de libération en un seul endroit.

Accès conscient des rôles dans journal d'import/export

Définir qui peut consulter ou modifier les journaux d'expédition, les enregistrements de droits de douane et les notes d'audit.

REST/GraphQL APIs pour journal d'import/export

Intégrer des outils web, mobiles et de back-office avec le même contrat de backend.

Architecture de journal extensible pour journal d'import/export

Ajouter des exceptions, des résultats d'inspection ou des détails de conteneur plus tard sans changer le flux principal.

Comparaison du cadre d'importation/exportation

Comparez la vitesse de configuration, le style de SDK et le soutien à l'IA à travers toutes les technologies prises en charge.

Cadre	Temps de configuration	Avantage d'importation/exportation	Type de SDK	Assistance IA
Flutter	Environ 5 min	Codebase unique pour les journaux d'expédition sur mobile et web.	SDK typé	Complet
React	Moins de 5 minutes	Tableau de bord web rapide pour l'historique des entrées en douane.	SDK typé	Complet
React Natif	~3–7 min	Application mobile multiplateforme pour les journaux de service.	SDK tapé	Complet
Next.js	Configuration rapide (5 min)	Application web rendue sur serveur pour la révision HTS.	SDK tapé	Complet
JavaScript	~3–5 min	Intégration web légère pour les journaux d'importation/exportation.	SDK tapé	Complet
Android	Environ 5 min	Application Android native pour les mises à jour d'expédition sur le terrain.	SDK tapé	Complet
iOS	Moins de 5 minutes	Application iOS native pour la révision des entrées douanières.	SDK tapé	Complet
Vue	~3–7 min	Interface Web React pour les journaux d'expédition.	SDK tapé	Complet
Angular	Configuration rapide (5 min)	Application web d'entreprise pour le suivi des devoirs et des HTS.	SDK tapé	Complet
GraphQL	Moins de 2 minutes	API GraphQL flexible pour l'historique des douanes.	API GraphQL	Complet
REST API	Configuration rapide (2 min)	Intégration REST API pour les outils logistiques.	REST API	Complet
PHP	~3 minutes	Backend PHP côté serveur pour les journaux d'import/export.	REST API	Complet
.NET	~3–7 min	backend .NET pour les flux de travail d'expédition et de douane.	SDK tapé	Complet

Le temps de configuration reflète la durée attendue depuis le démarrage du projet jusqu'à la première requête d'expédition ou d'entrée en douane en utilisant ce schéma de modèle.

Questions Fréquemment Posées

Questions courantes sur la création d'un backend de journal d'importation/exportation avec ce modèle.

Quels contrôles de journaux d'importation/exportation sont les plus importants lorsque les opérations s'étendent sur plusieurs sites ?

Quelles relations entre Shipment, HTSCode et DutyLog facilitent la narration des audits de journaux d'importation/exportation ?

Pouvons-nous ajouter une notation de risque de journal d'importation/exportation ou des files d'attente d'exception sans une refonte ?

Comment interroger les expéditions et les journaux de droits dans Flutter ?

Comment gérer l'accès aux journaux d'importation/exportation avec Next.js Server Actions ?

Est-ce que React peut mettre en cache les déclarations en douane hors ligne ?

Comment puis-je empêcher les modifications non autorisées des codes HTS ?

Quelle est la meilleure façon d'afficher l'historique des déclarations en douane sur Android ?

Comment fonctionne le workflow du registre des droits de douane de bout en bout ?

Fiable pour les développeurs du monde entier

Rejoignez des équipes expédiant des produits de journal d'import/export plus rapidement avec des modèles Back4app

Prêt à créer votre application de journal d'import/export ?

Commencez votre projet de journal d'import/export en quelques minutes. Aucune carte de crédit requise.

Choisir la technologie

Modèle de journal d'importation/exportation BackendCodes HTS, journaux des droits et historique des entrées douanières