Backend de permis d'espace confiné

Modèle de backend d'application de permis d'espace confiné PH0
Suivi des permis pour espaces confinés

Q: Quels contrôles de permis d'espace confiné sont les plus importants lorsque les opérations s'étendent sur plusieurs sites ?

C'est un schéma BaaS et une API pour le suivi des permis dans les espaces confinés : permis, journaux de moniteur de gaz, agents et événements d'entrée ou de sortie.

Q: Quelles relations entre le suivi des permis, les journaux de surveillance des gaz, les noms des agents et les quarts rendent les audits des permis d'espace confiné plus faciles à raconter ?

Cela inclut le Permis (nomEspace, numéroPermis, statut, emplacement, délivréPar), GasMonitorLog (permis, pourcentageOxygène, h2sPpm, coPpm, lecturesÀ, nomMoniteur), Agent (permis, nomComplet, rôle, débutQuart, finQuart), et EntryEvent (permis, agent, heureEntrée, heureSortie, remarques), plus un diagramme ER, un terrain de jeu API et une invite d'agent AI.

Q: Est-il pratique d'exporter les preuves des permis d'espace confiné pour les examinateurs externes de manière structurée ?

Back4app fournit une base de données gérée, une authentification, des requêtes en temps réel et un schéma flexible afin que vous puissiez livrer le suivi des permis, les journaux de gaz, l'attribution des agents et la capture du temps sans gérer votre propre backend.

Q: Comment interroger les permis et les journaux de gaz avec Flutter ?

Utilisez les classes Permit et GasMonitorLog pour interroger le travail actif et les lectures récentes, puis affichez-les dans votre interface utilisateur Flutter.

Q: Comment gérer les données de permis avec Next.js Server Actions ?

Utilisez une action serveur pour créer un Permis, puis ajoutez des lignes GasMonitorLog et EntryEvent avec les pointeurs connexes. Validez éventuellement le flux de travail dans le Cloud Code.

Q: Est-ce que React Native peut mettre en cache les enregistrements de permis hors ligne ?

Oui. Activez le Local Datastore et épinglez les résultats de Permit et GasMonitorLog afin que les équipes puissent visualiser les détails et les lectures des permis sans connectivité.

Q: Comment puis-je prévenir l'accès non autorisé aux journaux de gaz ?

Dans le Cloud Code beforeSave pour GasMonitorLog, imposez la propriété du permis et rejetez les soumissions qui ne correspondent pas au permis actif.

Q: Quelle est la meilleure façon d'afficher le statut du permis sur Android ?

Interrogez les classes Permit et EntryEvent pour afficher le statut actuel du permis, la liste des agents et les dernières heures d'entrée ou de sortie.

Q: Comment fonctionne le flux de travail espace confiné de bout en bout ?

Les utilisateurs se connectent, chargent le permis actif, ajoutent des entrées GasMonitorLog, attribuent des noms d'agent et enregistrent les heures d'EntryEvent à mesure que le travail passe de la préparation à la sortie.

Un backend de permis d'espace confiné prêt pour la production sur Back4app avec journaux de moniteur de gaz, noms des agents et suivi des heures d'entrée/sortie. Inclut diagramme ER, dictionnaire de données, schéma JSON, terrain de jeu API, et un prompt Agent IA pour un démarrage rapide.

Construire avec l'Agent IA Choisissez votre technologie

Points à retenir du journal des permis

Ce modèle vous donne un backend de permis d'espace confiné avec des journaux de surveillance de gaz, des noms d'attendant et des heures d'entrée/sortie afin que le personnel des opérations puisse enregistrer les conditions d'entrée et garder les activités de permis organisées.

Enregistrements de permis en un seul endroit — Modélisez chaque permis avec son espace, son statut et son équipe autorisée dans des classes Parse claires.
Journaux de surveillance de gaz liés à chaque entrée — Stockez les lectures GasMonitorLog avec readingsAt et monitorName pour que les conditions soient faciles à examiner.
Attribution des attendants par nom — Suivez les noms et les quarts des attendants pour chaque permis au lieu de les conserver dans des notes ou des fils de discussion.
Heures d'entrée et de sortie que vous pouvez auditer — Utilisez les entrées EntryEvent avec entryTime et exitTime pour montrer qui était dans l'espace et quand.

Comprendre le back-end de l'application de permis d'espace confiné

Dans le permis d'espace confiné, « nous le faisons généralement comme ça » n'est pas un contrôle — les étapes documentées et les résultats capturés le sont. Le coût apparaît dans les rappels et les crédits. Modélisez le permis, le GasMonitorLog, l'Attendant et l'EntryEvent sur Back4app pour rendre les contrôles du permis d'espace confiné opérationnels : approbations, preuves et exceptions capturées là où le travail se déroule réellement. Le schéma couvre le permis (spaceName, permitNumber, status), le GasMonitorLog (permit, oxygenPct, h2sPpm, coPpm, readingsAt, monitorName), l'Attendant (permit, fullName, role, shiftStart, shiftEnd), et l'EntryEvent (permit, attendant, entryTime, exitTime, remarks) avec autorisation et structure au niveau du champ déjà en place. Connectez votre frontend préféré et commencez à enregistrer les activités d'espace confiné plus rapidement.

Meilleur pour :

Suivi des permis d'espace confinéCapture du journal de surveillance des gazPlanification et noms des agentsEnregistrements des heures d'entrée et de sortieÉquipes d'opérations et de maintenanceÉquipes sélectionnant BaaS pour les flux de travail de permis

Ce que vous obtenez dans le modèle de permis d'espace confiné

Les meilleurs tableaux de bord de permis d'espace confiné sont ennuyeux car les entités sous-jacentes sont propres — pas parce que quelqu'un a modifié une feuille de calcul à minuit.

Le hub met en évidence Permit, GasMonitorLog et Attendant afin que vous puissiez comparer les piles de clients par rapport aux mêmes entités, champs et relations.

Fonctionnalités clés du permis d'espace confiné

Chaque carte technologique dans ce hub utilise le même schéma de permis d'espace confiné avec Permis, JournalGasMonitor, Agent et EntryEvent.

Suivi des permis

La classe Permis stocke spaceName, permitNumber, status et location.

Journaux du moniteur de gaz

La classe GasMonitorLog capture oxygenPct, h2sPpm, coPpm, readingsAt et monitorName.

Noms et quarts des assistants

La classe Attendant stocke fullName, role, shiftStart et shiftEnd.

Heures d'entrée et de sortie

La classe EntryEvent relie le permis, l'agent, l'heure d'entrée, l'heure de sortie et les remarques.

Pourquoi construire votre backend de permis d'espace confiné avec Back4app ?

Back4app vous fournit des primitives pour les permis, les gaz, les agents et les événements d'entrée afin que votre équipe puisse se concentrer sur le flux de travail sur le terrain plutôt que sur la maintenance backend.

•Autoriser et structure de journal: Les classes Permit et GasMonitorLog conservent chaque espace, lecture et nom de surveillant dans un format interrogeable.
•Suivi des préposés et du temps: Les champs Attendant et EntryEvent tels que fullName, entryTime et exitTime rendent l'examen des shifts simple.
•Options de l'API en temps réel: Utilisez Live Queries pour de nouvelles lignes GasMonitorLog tout en conservant REST et GraphQL disponibles pour chaque client.

Construisez et examinez rapidement des workflows de permis d'espace confiné avec un contrat backend unique sur le web, mobile et les outils administratifs.

Avantages principaux du permis

Un backend de permis d'espace confiné qui vous aide à garder les relevés de gaz, les noms et les horodatages organisés.

Lancement rapide de permis

Commencez à partir d'un schéma complet de Permis, JournalGasMonitor, Agent et EntryEvent au lieu de créer des enregistrements à partir de zéro.

Effacer l'historique des lectures de gaz

Stockez les valeurs d'oxygènePct, h2sPpm et coPpm avec readingsAt afin que chaque lecture ait une trace de révision.

Enregistrements des nommés

Utilisez Attendant.fullName et Attendant.role pour identifier qui a couvert l'espace et qui a surveillé l'entrée.

Responsabilité d'entrée et de sortie

Maintenez EntryEvent.entryTime et EntryEvent.exitTime attachés au même permis pour un examen de poste plus clair.

Surface API unique

Exposez les données de permis, journal de gaz, attendant et événement d'entrée via REST et GraphQL sans changer le modèle.

Configuration assistée par AI

Générez rapidement l'échafaudage backend et les notes d'intégration avec une seule invite structurée adaptée aux données de permis d'espace confiné.

Prêt à lancer votre application de permis d'espace confiné ?

Laissez l'agent IA de Back4app structurer votre backend de permis d'espace confiné et générer des journaux de gaz, des noms d'accompagnateurs et des flux de temps d'entrée/sortie à partir d'une seule invite.

Construire avec l'agent IA Essayez l'API Playground

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

Stack technique

Tout est inclus dans ce modèle de backend de permis d'espace confiné.

Interface utilisateur

13+ technologies

Backend

Back4app

Base de données

MongoDB

Authentification

Authentification intégrée + sessions

API

REST et GraphQL

Temps réel

Live Queries

Diagramme ER de permis

Modèle de relation d'entité pour le schéma backend du permis de travail en espace confiné.

Diagramme ER

Voir la source du diagramme

Mermaid

erDiagram
    User ||--o{ Permit : "issuedBy"
    User ||--o{ GasMonitorLog : "monitoredBy"
    User ||--o{ AttendantAssignment : "attendant"
    User ||--o{ EntryExitLog : "person"
    ConfinedSpace ||--o{ Permit : "confinedSpace"
    Permit ||--o{ GasMonitorLog : "permit"
    Permit ||--o{ AttendantAssignment : "permit"
    Permit ||--o{ EntryExitLog : "permit"

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

    ConfinedSpace {
        String objectId PK
        String spaceTag
        String location
        String hazardNotes
        String status
        Date createdAt
        Date updatedAt
    }

    Permit {
        String objectId PK
        String permitNumber
        String confinedSpaceId FK
        String issuedById FK
        String entryPurpose
        String permitStatus
        Date validFrom
        Date validTo
        Date createdAt
        Date updatedAt
    }

    GasMonitorLog {
        String objectId PK
        String permitId FK
        String monitoredById FK
        Number oxygenPercent
        Number lelPercent
        Number h2sPpm
        Number coPpm
        Date loggedAt
        Date createdAt
        Date updatedAt
    }

    AttendantAssignment {
        String objectId PK
        String permitId FK
        String attendantId FK
        String shiftName
        String assignmentStatus
        Date createdAt
        Date updatedAt
    }

    EntryExitLog {
        String objectId PK
        String permitId FK
        String personId FK
        String eventType
        Date eventTime
        String notes
        Date createdAt
        Date updatedAt
    }

Flux d'intégration des permis

Flux d'exécution typique pour la connexion, la recherche de permis, l'enregistrement du moniteur de gaz, l'attribution de préposés et la capture du temps d'entrée ou de sortie.

Diagramme ER

Voir la source du diagramme

Mermaid

sequenceDiagram
  participant User
  participant App as Confined Space Permit App
  participant Back4app as Back4app Cloud

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

  User->>App: Load permits for a spaceTag
  App->>Back4app: GET /classes/Permit?include=confinedSpace,issuedBy
  Back4app-->>App: Permit list

  User->>App: Add gas monitor log
  App->>Back4app: POST /classes/GasMonitorLog
  Back4app-->>App: GasMonitorLog objectId

  User->>App: Record attendant assignment and entry/exit times
  App->>Back4app: POST /classes/AttendantAssignment
  App->>Back4app: POST /classes/EntryExitLog
  Back4app-->>App: Assignment and time log saved

Dictionnaire de données des permis

Référence au niveau des champs pour chaque classe dans le schéma de permis d'espace confiné.

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, attendant, worker)
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

7 champs dans User

Sécurité et Autorisations

Comment la stratégie ACL et CLP sécurise les permis, les journaux de gaz, les attendants et les événements d'entrée.

Contrôles de propriété du permis

Seuls les utilisateurs autorisés peuvent créer, mettre à jour ou clore un permis pour un travail en espace confiné.

Intégrité des journaux de gaz

Les entrées GasMonitorLog doivent être créées par des utilisateurs authentifiés, avec Cloud Code validant readingsAt et monitorName.

Accès limité aux données de l'équipe

Restreindre les lectures d'Attendant et d'EntryEvent au groupe de travail qui possède le permis afin que les noms et horaires ne soient pas exposés largement.

Schéma (JSON)

Définition du schéma JSON brut prête à être copiée dans Back4app ou utilisée comme référence de mise en œuvre.

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

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

{
  "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": "ConfinedSpace",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "spaceTag": {
          "type": "String",
          "required": true
        },
        "location": {
          "type": "String",
          "required": true
        },
        "hazardNotes": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Permit",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "permitNumber": {
          "type": "String",
          "required": true
        },
        "confinedSpace": {
          "type": "Pointer",
          "required": true,
          "targetClass": "ConfinedSpace"
        },
        "issuedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "entryPurpose": {
          "type": "String",
          "required": true
        },
        "permitStatus": {
          "type": "String",
          "required": true
        },
        "validFrom": {
          "type": "Date",
          "required": true
        },
        "validTo": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "GasMonitorLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "permit": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Permit"
        },
        "monitoredBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "oxygenPercent": {
          "type": "Number",
          "required": true
        },
        "lelPercent": {
          "type": "Number",
          "required": true
        },
        "h2sPpm": {
          "type": "Number",
          "required": true
        },
        "coPpm": {
          "type": "Number",
          "required": true
        },
        "loggedAt": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AttendantAssignment",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "permit": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Permit"
        },
        "attendant": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "shiftName": {
          "type": "String",
          "required": true
        },
        "assignmentStatus": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "EntryExitLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "permit": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Permit"
        },
        "person": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "eventType": {
          "type": "String",
          "required": true
        },
        "eventTime": {
          "type": "Date",
          "required": true
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construire avec l'agent AI

Utilisez l'agent AI Back4app pour générer une véritable application de permis d'espace confiné à partir de ce modèle, y compris le frontend, le backend, l'authentification, et les flux de permis, journal des gaz, attendant et événement d'entrée.

Back4app Agent AI

Prêt à construire

Créez un backend d'application de permis d'espace confiné sur Back4app avec ce schéma et ce comportement exact.

Schéma:
1. Utilisateur (utiliser Back4app intégré): nom d'utilisateur, email, mot de passe; objectId, createdAt, updatedAt (système).
2. Permis: nomDeLEspace (Chaîne, requis), numéroDePermis (Chaîne, requis), statut (Chaîne, requis), localisation (Chaîne), émisPar (Pointeur vers l'utilisateur, requis); objectId, createdAt, updatedAt (système).
3. JournalDeSurveillanceDesGaz: permis (Pointeur vers le permis, requis), oxygenePct (Nombre, requis), h2sPpm (Nombre, requis), coPpm (Nombre, requis), lecturesÀ (Date, requis), nomDuMoniteur (Chaîne, requis); objectId, createdAt, updatedAt (système).
4. Attendant: permis (Pointeur vers le permis, requis), nomComplet (Chaîne, requis), rôle (Chaîne, requis), débutDeShift (Date, requis), finDeShift (Date); objectId, createdAt, updatedAt (système).
5. ÉvénementDEntrée: permis (Pointeur vers le permis, requis), attendant (Pointeur vers l'attendant, requis), heureDEntrée (Date, requis), heureDeSortie (Date), remarques (Chaîne); objectId, createdAt, updatedAt (système).

Sécurité:
- Seuls les utilisateurs autorisés peuvent créer, mettre à jour ou fermer un permis. Validez les lectures de gaz et la propriété du permis dans Cloud Code.

Auth:
- Inscription, connexion, déconnexion.

Comportement:
- Lister les permis, créer des journaux de surveillance des gaz, assigner des attendants et enregistrer les heures d'entrée ou de sortie.

Livrer:
- application Back4app avec schéma, ACLs, CLPs; frontend pour le suivi des permis, journaux de gaz, attendants et événements d'entrée.

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

Ceci est 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 permis d'espace confiné. 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 Permit, GasMonitorLog, et Attendant avec votre pile choisie.

Ce que vous obtenez avec chaque technologie

Chaque pile utilise le même schéma de permis d'espace confiné et contrats API.

Structure de données de permis unifiée

Suivez les permis, les journaux de gaz, les agents et les événements d'entrée dans un modèle cohérent.

Journaux de monitorage de gaz pour espaces confinés

Stockez les champs oxygenPct, h2sPpm, coPpm et readingsAt pour chaque lecture.

Suivi des agents et du temps

Conservez fullName, shiftStart, entryTime et exitTime liés au bon permis.

Flux de travail de permis en fonction du rôle

Définir l'accès pour les responsables, les coordinateurs et le personnel sur le terrain autour des dossiers de permis.

REST/GraphQL APIs pour les applications de permis

Intégrer des outils web, mobiles ou back-office avec un seul contrat backend.

Comparaison du cadre de permis

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

Cadre	Temps de configuration	Avantage du permis	Type de SDK	Support de l'IA
Flutter	Environ 5 min	Code source unique pour l'enregistrement des permis sur mobile et web.	SDK tapé	Complet
React	Moins de 5 minutes	Tableau de bord web rapide pour la révision des permis.	SDK tapé	Complet
React Natif	~3–7 min	Application mobile multiplateforme pour les journaux de permis et de gaz.	SDK tapé	Complet
Next.js	Configuration rapide (5 min)	Application web rendue sur serveur pour les opérations de permis.	SDK typé	Complet
JavaScript	~3-5 min	Intégration web légère pour les données de permis.	SDK typé	Complet
Android	Environ 5 min	Application Android native pour l'enregistrement des permis sur le terrain.	SDK typé	Complet
iOS	Moins de 5 minutes	Application native iOS pour les horaires de permis et d'entrée.	SDK typé	Complet
Vue	~3–7 min	Interface web Reactive pour l'examen des permis.	SDK typé	Complet
Angular	Configuration rapide (5 min)	Application web d'entreprise pour les opérations de permis.	SDK typé	Complet
GraphQL	Moins de 2 min	API GraphQL flexible pour les données de permis.	API GraphQL	Complet
REST API	Configuration rapide (2 min)	Intégration REST API pour les systèmes de permis.	REST API	Complet
PHP	~3 min	Backend PHP côté serveur pour les workflows de permis.	REST API	Complet
.NET	~3–7 min	.NET backend pour le suivi des permis.	SDK typé	Complet

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

Questions Fréquemment Posées

Questions courantes sur la création d'un backend de permis d'espace confiné avec ce modèle.

Quels contrôles de permis d'espace confiné sont les plus importants lorsque les opérations s'étendent sur plusieurs sites ?

Quelles relations entre le suivi des permis, les journaux de surveillance des gaz, les noms des agents et les quarts rendent les audits des permis d'espace confiné plus faciles à raconter ?

Est-il pratique d'exporter les preuves des permis d'espace confiné pour les examinateurs externes de manière structurée ?

Comment interroger les permis et les journaux de gaz avec Flutter ?

Comment gérer les données de permis avec Next.js Server Actions ?

Est-ce que React Native peut mettre en cache les enregistrements de permis hors ligne ?

Comment puis-je prévenir l'accès non autorisé aux journaux de gaz ?

Quelle est la meilleure façon d'afficher le statut du permis sur Android ?

Comment fonctionne le flux de travail espace confiné de bout en bout ?

Fiable par des développeurs du monde entier

Rejoignez des équipes expédiant des produits de suivi des permis plus rapidement avec les modèles Back4app

Prêt à construire votre application de permis d'espace confiné ?

Démarrez votre projet de permis en quelques minutes. Pas de carte de crédit requise.

Choisir la technologie

Modèle de backend d'application de permis d'espace confiné __PH0__Suivi des permis pour espaces confinés