Backend de conformité LOTO

Modèle de backend d'application de verrouillage et d'étiquetage (LOTO)
Journaux de source d'énergie et attributions de cadenas

Q: À quoi ressemble une piste d'audit loto crédible de bout en bout ?

Un backend Lockout Tagout est un schéma et une API BaaS pour suivre les journaux des sources d'énergie, les attributions de cadenas et les pistes d'audit à travers le travail de maintenance.

Q: Quelles relations entre les journaux des sources d'énergie, les entrées du journal de verrouillage et le suivi des attributions de cadenas facilitent la narration des audits loto ?

Il comprend Utilisateur (nom d'utilisateur, email, mot de passe), SourceD'Énergie (equipmentId, sourceType, isolationState), JournalDeVerrouillage (source, initiatedBy, lockStatus, notes), AttributionDeCadenas (lockoutLog, padlockId, assignee, verifiedAt) et PisteDAudit (entityType, entityId, action, performedBy, occurredAt), ainsi qu'un diagramme ER, un terrain de jeu API et une invite d'agent AI.

Q: Comment étendons-nous les flux de travail loto pour des approbations en plusieurs étapes sans rompre l'historique ?

Back4app fournit une base de données gérée, des authentifications, des requêtes en temps réel et un schéma flexible afin que vous puissiez expédier des journaux d'isolement énergétique, le suivi de la garde des cadenas et des pistes d'audit sans faire fonctionner votre propre backend.

Q: Comment exécuter des requêtes pour EnergySource et LockoutLog avec Flutter ?

Utilisez les classes EnergySource et LockoutLog pour interroger et afficher l'état de la source et des cas ouverts, en utilisant le SDK Back4app.

Q: Comment gérer l'accès loto avec Next.js Server Actions ?

Utilisez une action serveur pour créer un objet Parse pour LockoutLog avec des pointeurs source et initiatedBy. Validez éventuellement l'état de verrouillage dans Cloud Code.

Q: Est-ce que React peut mettre en cache les affectations de cadenas hors ligne ?

Oui. Activez le magasin de données local et épinglez les résultats de PadlockAssignment et LockoutLog afin que les techniciens puissent consulter les affectations sans connexion.

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

Dans le Cloud Code avantSave pour LockoutLog et PadlockAssignment, appliquez des contrôles de rôle et de propriété et rejetez les changements d'état invalides.

Q: Quelle est la meilleure façon d'afficher les journaux d'énergie sur Android ?

Interrogez les classes EnergySource et LockoutLog pour afficher equipmentId, sourceType, isolationState et statut de verrouillage, en utilisant le SDK Back4app pour la gestion des données.

Q: Comment fonctionne le flux d'affectation de cadenas de bout en bout ?

Un coordonnateur ouvre un LockoutLog pour une EnergySource, attribue des cadenas via PadlockAssignment, puis enregistre chaque changement dans AuditTrail pour une révision ultérieure.

Q: Quelles classes alimentent ce modèle LOTO ?

Le modèle principal inclut User (nom d'utilisateur, email, mot de passe), EnergySource (equipmentId, sourceType, isolationState), LockoutLog (source, initiatedBy, lockStatus, notes), PadlockAssignment (lockoutLog, padlockId, assignee, verifiedAt), et AuditTrail (entityType, entityId, action, performedBy, occurredAt).

Un backend de verrouillage et d'étiquetage (LOTO) prêt pour la production sur Back4app avec des journaux de source d'énergie, des attributions de cadenas et des pistes d'audit. Inclut un diagramme ER, un dictionnaire de données, un schéma JSON, une aire de jeux API, et un prompt Agent IA pour un démarrage rapide.

Construire avec l'Agent IA Choisissez votre technologie

Principaux points à retenir sur le LOTO

Ce modèle vous fournit un backend LOTO pour les journaux des sources d'énergie, les attributions de cadenas et les pistes de vérification afin que les coordinateurs puissent documenter les étapes d'isolement avec moins de travail d'installation.

Suivi des journaux des sources d'énergie — Modélisez les enregistrements EnergySource et LockoutLog afin que chaque étape d'isolement soit liée à l'équipement, au type de source et à l'état.
Contrôle de l'attribution des cadenas — Attribuez des entrées PadlockAssignment aux techniciens, dispositifs et cas de verrouillage avec une propriété traçable.
Visibilité de la piste de vérification — Capturez les événements AuditTrail pour les signatures, les libérations et les actions de vérification tout au long du flux de travail loto.
Accès conscient du rôle — Utilisez les permissions Back4app pour séparer les actions des coordinateurs, des gestionnaires et du personnel de terrain sur les données LOTO.
Backend de conformité multiplateforme — Servez les équipes mobiles et web grâce à une API REST et GraphQL pour les écrans de verrouillage, d'étiquetage et de révision.

Aperçu : Application Lockout Tagout (LOTO)

Lorsque le risque loto augmente, la direction demande des délais — ce qui signifie que votre système doit relier les événements en un récit cohérent rapidement. Back4app garde les horodatages et les attributions d'EnergySource, LockoutLog, PadlockAssignment, et AuditTrail — la base nécessaire pour les équipes loto lors des contrôles. Le schéma couvre l'utilisateur (nom d'utilisateur, e-mail, mot de passe), EnergySource (equipmentId, sourceType, isolationState), LockoutLog (source, initiatedBy, lockStatus, notes), PadlockAssignment (lockoutLog, padlockId, assignee, verifiedAt), et AuditTrail (entityType, entityId, action, performedBy, occurredAt) avec des fonctionnalités d'authentification et de traçabilité intégrées. Connectez votre frontend préféré et expédiez plus rapidement.

Meilleur pour :

Suivi Lockout TagoutJournaux d'isolement d'énergieFlux de travail d'attribution de cadenasOutils de révision de la piste d'auditApplications de coordination de maintenanceÉquipes sélectionnant BaaS pour les produits LOTO

Ce que vous obtenez dans le modèle Loto

Dans loto, de petites incohérences s'accumulent : un mauvais statut devient un mauvais envoi, puis une mauvaise facture, puis un client perdu.

Examinez d'abord EnergySource, LockoutLog et PadlockAssignment, puis ouvrez une carte de pile pour voir les notes spécifiques au SDK et les modèles d'intégration.

Fonctionnalités principales de LOTO

Chaque carte technologique dans ce hub utilise le même schéma LOTO avec EnergySource, LockoutLog, PadlockAssignment et AuditTrail.

Journaux des sources d'énergie

EnergySource stocke equipmentId, sourceType et isolationState.

Entrées de journal de consignation

LockoutLog relie la source, lockStatus et l'utilisateur initiant.

Suivi d'attribution de cadenas

PadlockAssignment stocke padlockId, assignee et verifiedAt.

Historique des pistes d'audit

AuditTrail enregistre entityType, entityId, action, performedBy et occurredAt.

Pourquoi construire votre backend de verrouillage et d'étiquetage (LOTO) avec Back4app ?

Back4app vous fournit des primitives d'énergie, de verrouillage, de cadenas et d'audit afin que votre équipe puisse se concentrer sur l'exécution sur le site au lieu de la maintenance du backend.

•Journaux de source d'énergie et dossiers d'isolation: Les classes EnergySource et LockoutLog conservent le type de source, l'état d'isolation et les notes de verrouillage dans un modèle consultable.
•Suivi d'attribution de cadenas: Les enregistrements PadlockAssignment lient chaque padlockId à un LockoutLog et à un assignataire, ce qui aide les coordinateurs à confirmer la garde.
•Piste d'audit et flux de révision: Les événements AuditTrail capturent performedBy, action et occurredAt afin que les superviseurs puissent examiner chaque étape de libération ou de vérification.

Construisez et itérez rapidement sur les workflows LOTO avec un seul contrat backend sur toutes les plateformes.

Avantages principaux du LOTO

Un backend Lockout Tagout qui aide les équipes à documenter le travail d'isolement sans perdre le fil.

Configuration de blocage plus rapide

Commencez à partir des objets EnergySource et LockoutLog au lieu d'inventer un nouveau workflow d'isolement à partir de zéro.

Custodie de cadenas claire

Utilisez PadlockAssignment pour montrer quel assigné contrôle quel padlockId à tout moment.

Révision d'audit simple

AuditTrail fournit aux managers une chronologie des actions sur chaque journal de verrouillage et source.

Accès aux champs ciblés

Restreindre qui peut éditer un LockoutLog, changer une EnergySource ou réaffecter un PadlockAssignment.

Enregistrements de source et d'équipement

Maintenez l'équipementId, le typeDeSource et le statutDeVerrou visibles entre les équipes sans reconstruire le modèle.

Flux de travail de démarrage AI

Générez rapidement une structure backend et des conseils d'intégration avec une invite structurée.

Prêt à lancer votre application LOTO ?

Laissez l'agent AI de Back4app structurer votre backend Lockout Tagout et générer des journaux de sources d'énergie, des attributions de cadenas et des pistes d'audit à partir d'une invite.

Construisez avec l'Agent AI Essayez le Playground API

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

Pile technique

Tout inclus dans ce modèle de backend Lockout Tagout.

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 LOTO

Modèle de relation d'entité pour le schéma backend Lockout Tagout.

Diagramme ER

Voir la source du diagramme

Mermaid

erDiagram
    User ||--o{ EnergySource : "createdBy"
    User ||--o{ LockoutAssignment : "assignedTo"
    User ||--o{ AuditTrail : "performedBy"
    EnergySource ||--o{ LockoutAssignment : "source"
    EnergySource ||--o{ AuditTrail : "source"
    LockoutAssignment ||--o{ AuditTrail : "assignment"

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

    EnergySource {
        String objectId PK
        String sourceTag
        String equipmentName
        String energyType
        String status
        String location
        String createdById FK
        Date createdAt
        Date updatedAt
    }

    LockoutAssignment {
        String objectId PK
        String assignmentCode
        String sourceId FK
        String assignedToId FK
        String padlockNumber
        String tagStatus
        Boolean isVerified
        Date issuedAt
        Date createdAt
        Date updatedAt
    }

    AuditTrail {
        String objectId PK
        String eventType
        String assignmentId FK
        String sourceId FK
        String performedById FK
        String notes
        Date eventAt
        Date createdAt
        Date updatedAt
    }

Flux d'intégration LOTO

Flux d'exécution typique pour la connexion, l'inspection des sources, la création de journal de verrouillage, l'attribution de cadenas et la révision d'audit.

Diagramme ER

Voir la source du diagramme

Mermaid

sequenceDiagram
  participant User
  participant App as Lockout Tagout (LOTO) App
  participant Back4app as Back4app Cloud

  User->>App: Sign in to open the LOTO dashboard
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Review energy source logs
  App->>Back4app: GET /classes/EnergySource?include=createdBy&order=-updatedAt
  Back4app-->>App: EnergySource list with sourceTag, equipmentName, status

  User->>App: Issue a padlock assignment
  App->>Back4app: POST /classes/LockoutAssignment
  Back4app-->>App: LockoutAssignment objectId and padlockNumber

  User->>App: Record an audit event
  App->>Back4app: POST /classes/AuditTrail
  Back4app-->>App: AuditTrail objectId

  App->>Back4app: Live query updates for assignment and source changes
  Back4app-->>App: Updated lockout trail and verification state

Dictionnaire de données LOTO

Référence complète au niveau des champs pour chaque classe dans le schéma de Lockout Tagout.

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	User role for LOTO work (e.g., manager, coordinator, technician)
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 utilisateurs, les sources d'énergie, les journaux de verrouillage, les attributions de cadenas et les pistes de vérification.

Contrôles d'identité appartenant à l'utilisateur

Seul l'utilisateur peut mettre à jour ou supprimer son profil ; les autres ne peuvent pas modifier le contenu de l'utilisateur.

Intégrité des enregistrements de verrouillage

Seuls les rôles autorisés peuvent créer ou fermer des entrées LockoutLog, et le Cloud Code peut rejeter des états de source invalides.

Accès en lecture limité

Restreindre les lectures de EnergySource, PadlockAssignment et AuditTrail aux gestionnaires, coordinateurs et employés de terrain assignés pertinents.

Schéma LOTO (JSON)

Définition de 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

{
  "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": "EnergySource",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "sourceTag": {
          "type": "String",
          "required": true
        },
        "equipmentName": {
          "type": "String",
          "required": true
        },
        "energyType": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "location": {
          "type": "String",
          "required": true
        },
        "createdBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "LockoutAssignment",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "assignmentCode": {
          "type": "String",
          "required": true
        },
        "source": {
          "type": "Pointer",
          "required": true,
          "targetClass": "EnergySource"
        },
        "assignedTo": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "padlockNumber": {
          "type": "String",
          "required": true
        },
        "tagStatus": {
          "type": "String",
          "required": true
        },
        "isVerified": {
          "type": "Boolean",
          "required": true
        },
        "issuedAt": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AuditTrail",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "eventType": {
          "type": "String",
          "required": true
        },
        "assignment": {
          "type": "Pointer",
          "required": true,
          "targetClass": "LockoutAssignment"
        },
        "source": {
          "type": "Pointer",
          "required": true,
          "targetClass": "EnergySource"
        },
        "performedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "eventAt": {
          "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 vraie application de Lockout Tagout à partir de ce modèle, y compris l'interface utilisateur, le backend, l'authentification et les flux de source d'énergie, d'attribution de cadenas et d'audit.

Agent IA Back4app

Prêt à construire

Créez un backend d'application Lockout Tagout (LOTO) sur Back4app avec ce schéma et ce comportement exacts.

Schéma :
1. Utilisateur (utiliser Back4app intégré) : nom d'utilisateur, email, mot de passe ; objectId, createdAt, updatedAt (système).
2. SourceD'énergie : equipmentId (String, requis), sourceType (String, requis), isolationState (String, requis), lastInspectionAt (Date), areaName (String), objectId, createdAt, updatedAt (système).
3. LockoutLog : source (Pointeur vers SourceD'énergie, requis), initiatedBy (Pointeur vers Utilisateur, requis), lockStatus (String, requis), notes (String), openedAt (Date, requis), closedAt (Date) ; objectId, createdAt, updatedAt (système).
4. PadlockAssignment : lockoutLog (Pointeur vers LockoutLog, requis), padlockId (String, requis), assignee (Pointeur vers Utilisateur, requis), verifiedAt (Date), verificationNote (String) ; objectId, createdAt, updatedAt (système).
5. AuditTrail : entityType (String, requis), entityId (String, requis), action (String, requis), performedBy (Pointeur vers Utilisateur, requis), occurredAt (Date, requis), details (String) ; objectId, createdAt, updatedAt (système).

Sécurité :
- Seul l'utilisateur peut mettre à jour/supprimer son profil. Seuls les rôles autorisés peuvent créer ou fermer des journaux de verrouillage. Utilisez Cloud Code pour la validation.

Auth :
- Inscription, connexion, déconnexion.

Comportement :
- Lister les sources d'énergie, ouvrir des journaux de verrouillage, assigner des cadenas, et écrire des événements de journal d'audit.

Livrer :
- Application Back4app avec schéma, ACL, CLP ; frontend pour les journaux de sources d'énergie, les journaux de verrouillage, les assignations de cadenas, et les révisions d'audit.

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 un 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 endpoints REST et GraphQL contre le schéma LOTO. 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 EnergySource, LockoutLog, et PadlockAssignment avec votre stack choisi.

Ce que vous obtenez avec chaque technologie

Chaque stack utilise le même schéma de backend Lockout Tagout et les contrats API.

Structure de données LOTO unifiée

Gérez les sources d'énergie, les journaux de verrouillage, les attributions de cadenas et les pistes d'audit avec un seul schéma.

Flux de travail d'isolement traçable

Enregistrez qui a isolé chaque source, qui a reçu chaque cadenas, et ce qui a changé dans la piste d'audit.

Revue en temps réel pour les équipes LOTO

Tenez les responsables et le personnel de terrain informés lorsque les journaux de verrouillage ou les missions changent.

Accès conscient du rôle pour les tâches LOTO

Définissez des niveaux d'accès et des autorisations adaptés aux coordinateurs, techniciens et superviseurs.

REST/GraphQL APIs pour LOTO

Intégrez des applications mobiles, des tableaux de bord et des outils de service avec des APIs flexibles.

Comparaison de la Technologie LOTO

Comparez la vitesse de configuration, le style SDK, et le support AI à travers toutes les technologies prises en charge.

Cadre	Temps de configuration	Avantage LOTO	Type de SDK	Support AI
Flutter	Environ 5 min	Base de code unique pour les inspections sur le terrain et les tableaux de bord LOTO.	SDK typé	Complet
React	Moins de 5 minutes	Tableau de bord web rapide pour les opérations LOTO.	SDK typé	Complet
React Natif	~3–7 min	Application mobile multiplateforme pour les rondes de verrouillage.	SDK typé	Complet
Next.js	Configuration rapide (5 min)	Application web rendue par serveur pour l'examen de conformité.	SDK typé	Complet
JavaScript	~3–5 min	Intégration légère pour les outils LOTO et kiOSks.	SDK typé	Complet
Android	Environ 5 min	Application Android native pour les équipes de terrain.	SDK typé	Complet
iOS	Moins de 5 minutes	Application iOS native pour les superviseurs de maintenance.	SDK typé	Complet
Vue	~3 à 7 min	Interface web Reactive pour les check-lists LOTO.	SDK typé	Complet
Angular	Configuration rapide (5 min)	Application web d'entreprise pour les programmes de sécurité.	SDK tapé	Complet
GraphQL	Moins de 2 min	API GraphQL flexible pour les journaux d'énergie et les attributions.	API GraphQL	Complet
REST API	Configuration rapide (2 min)	Intégration REST API pour les systèmes LOTO.	REST API	Complet
PHP	~3 min	Intégration côté serveur de PHP pour les portails de maintenance.	REST API	Complet
.NET	~3–7 min	Backend .NET pour les opérations de sécurité.	SDK typé	Complet

Le temps de configuration reflète la durée estimée depuis le démarrage du projet jusqu'à la première requête EnergySource ou LockoutLog utilisant ce schéma de modèle.

Questions Fréquemment Posées

Questions courantes sur la création d'un backend Lockout Tagout avec ce modèle.

À quoi ressemble une piste d'audit loto crédible de bout en bout ?

Quelles relations entre les journaux des sources d'énergie, les entrées du journal de verrouillage et le suivi des attributions de cadenas facilitent la narration des audits loto ?

Comment étendons-nous les flux de travail loto pour des approbations en plusieurs étapes sans rompre l'historique ?

Comment exécuter des requêtes pour EnergySource et LockoutLog avec Flutter ?

Comment gérer l'accès loto avec Next.js Server Actions ?

Est-ce que React peut mettre en cache les affectations de cadenas hors ligne ?

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

Quelle est la meilleure façon d'afficher les journaux d'énergie sur Android ?

Comment fonctionne le flux d'affectation de cadenas de bout en bout ?

Quelles classes alimentent ce modèle LOTO ?

De confiance pour les développeurs du monde entier

Rejoignez des équipes expédiant des produits de Lockout Tagout plus rapidement avec les modèles Back4app

Prêt à créer votre application LOTO ?

Commencez votre projet de Lockout Tagout en quelques minutes. Aucune carte de crédit requise.

Choisissez la technologie

Modèle de backend d'application de verrouillage et d'étiquetage (LOTO)Journaux de source d'énergie et attributions de cadenas