Backend dell'archivio dei pali della luce stradale

Modello del backend dell'archivio dei pali della luce stradale
Inventario dei pali, tracciamento dei tipi di lampadine e storia della manutenzione

Q: Come appare una traccia di audit credibile dell'archivio dei lampioni da cima a fondo?

È uno schema backend e un'API per tracciare pali, tipi di lampadine, registri dei ballasti e storia della manutenzione in un unico posto.

Q: Come catturano i programmi di archivio dei lampioni formazione, attestazioni e azioni correttive in modo pulito?

Include Pole, BulbType, BallastLog e MaintenanceEntry, oltre a un diagramma ER, playground API, dizionario dati e prompt AI Agent.

Q: Qual è il percorso consigliato per restringere i permessi dell'archivio dei lampioni man mano che l'organizzazione cresce?

Back4app fornisce autenticazione gestita, archiviazione database, Live Queries, e API REST e GraphQL in modo da poter mantenere la storia dei pali aggiornata senza gestire i propri server.

Q: Come posso interrogare i dettagli del palo in Flutter?

Utilizza le classi Pole e BulbType per caricare locationName, status e specifiche della lampada nella tua interfaccia utente di Flutter.

Q: Come costruisco un dashboard di Next.js per la storia della manutenzione?

Interroga i record di MaintenanceEntry e BallastLog sul server, quindi visualizza la traccia di servizio del palo nelle tue pagine di Next.js.

Q: Può React memorizzare localmente i record dei pali?

Sì. Fissa i risultati di Pole e BallastLog localmente in modo che i tecnici possano rivedere le voci dell'archivio recente senza connettività.

Q: Come posso fermare modifiche non autorizzate alle voci di manutenzione?

Utilizza la convalida del Cloud Code e i permessi affinché solo gli utenti approvati possano scrivere record di MaintenanceEntry e BallastLog.

Q: Qual è il modo migliore per mostrare i dati del tipo di lampadina su Android?

Interroga BulbType e collegalo a ciascun Polo in modo che l'app possa visualizzare tecnologia, wattaggio e ore di vita insieme.

Un backend di archivio dei pali della luce stradale pronto per la produzione su Back4app con registri dei pali, tracciamento dei tipi di lampadine, registri dei ballast e storia della manutenzione. Include diagramma ER, dizionario dei campi, schema JSON, area di lavoro API e un prompt AI Agent per un'impostazione rapida.

Costruisci con AI Agent Scegli la tua tecnologia

Punti chiave dell'archivio dei lampioni

Questo modello ti fornisce un backend di archivio per pali di lampioni con registri dei pali, monitoraggio del tipo di lampadina, registri dei reattori e storia della manutenzione, in modo che le squadre e i coordinatori possano lavorare da una fonte di verità comune.

Registri orientati ai pali — Modella ogni palo con ubicazione, stato, tipoDiLampadina e riferimenti ai registri dei reattori per un rapido accesso.
Visibilità del tipo di lampadina — Mantieni il tipo di lampadina, il wattaggio e le note di sostituzione attaccati all'archivio invece di sepolti nei fogli di calcolo.
Storia dei registri dei reattori — Archivia i registri dei reattori con date di servizio, note del tecnico e azioni di follow-up.
Tracciabilità della manutenzione — Collega la cronologia della manutenzione a un palo affinché ispezioni, riparazioni e sostituzioni rimangano facili da verificare.
Accesso all'archivio mobile e web — Servi le squadre di campo e il personale d'ufficio attraverso un backend REST e GraphQL per gli archivi dei pali.

Panoramica: Archivio dei Pali della Strada

Se la documentazione dell'archivio dei lampioni si trova nelle caselle di posta, sarai sempre a un allegato mancato da una scoperta che non puoi difendere. I clienti lo percepiscono nell'ETA che prometti. Questo modello struttura Pole, BulbType, BallastLog e MaintenanceEntry su Back4app con la traccia di audit integrata, in modo che le revisioni dell'archivio dei lampioni possano mostrare una linea temporale difendibile. Lo schema copre Pole (poleCode, locationName, poleType, status), BulbType (name, technology, wattage, lifespanHours), BallastLog (pole, ballastModel, serviceDate, technicianNote) e MaintenanceEntry (pole, actionType, performedAt, outcome) con flussi di lavoro di autorizzazione e archiviazione integrati. Collega il tuo frontend preferito e mantieni la cronologia dei pali organizzata.

Ideale per:

Sistemi di inventario dei lampioniArchivi di manutenzione dei paliApp per lavori pubbliciDashboard delle operazioni di utilitàLanci MVPSquadre che hanno bisogno di un BaaS per registri e log dei pali

Cosa ottieni nel modello di archivio dei lampioni

Buone abitudini di archivio dei lampioni assomigliano alla disciplina: gli stessi campi, lo stesso linguaggio del ciclo di vita e lo stesso tracciamento delle revisioni ogni volta.

Esamina prima Pole, BulbType e BallastLog, quindi apri una scheda di stack per vedere note specifiche dell'SDK e modelli di integrazione.

Caratteristiche principali dell'archivio dei pali di illuminazione

Ogni scheda tecnologica in questo hub utilizza lo stesso schema di archivio con Palo, BulbType, BallastLog e MaintenanceEntry.

Registro dei pali

La classe Pole memorizza i puntatori poleCode, locationName, poleType, status e bulbType.

Catalogo dei tipi di lampadine

La classe BulbType contiene nome, tecnologia, wattaggio e lifespanHours.

Tracciamento del log del ballast

La classe BallastLog registra palo, ballastModel, serviceDate e technicianNote.

Storia della manutenzione

La classe MaintenanceEntry memorizza palo, actionType, performedAt e outcome.

Perché costruire il tuo backend dell'archivio dei pali di illuminazione con Back4app?

Back4app ti fornisce le primitive dell'archivio dei pali—Pole, BulbType, BallastLog e MaintenanceEntry—così il tuo team può dedicare tempo alle ispezioni e alla cronologia invece di scrivere il codice di backend.

•Tracciamento di pali e lampadine: La classe Pole conserva poleCode, locationName, bulbType e status in un unico posto.
•Storia della manutenzione e del ballasts: BallastLog e MaintenanceEntry conservano le date di servizio, le note dei tecnici e i risultati per ogni palo.
•Accesso in tempo reale + API: Usa Live Queries per aggiornamenti di manutenzione freschi mentre esponi lo stesso archivio tramite REST e GraphQL.

Costruisci un archivio di pali pratico con un contratto backend unico su mobile, web e strumenti di campo.

Vantaggi principali per gli archivi dei pali

Un backend di archivio per lampioni che mantiene i dettagli del palo, i tipi di lampadina e la storia di servizio facili da interrogare.

Ricerche di poli più veloci

Cerca il Polo per poleCode o locationName invece di ordinare fogli di calcolo disconnessi.

Chiarezza del tipo di lampadina

Allega i campi BulbType come tecnologia e wattaggio a ciascun polo in modo che le squadre sappiano cosa stanno servendo.

Continuità del registro del ballast

Salva le voci di BallastLog con serviceDate e technicianNote in modo che i problemi ripetitivi siano visibili.

Storia che resta attaccata

Collega i record di MaintenanceEntry allo stesso Polo in modo che l'archivio mantenga una traccia completa del servizio.

Accesso ai dati a misura di campo

Utilizza un API per ispettori, supervisori e coordinatori d'ufficio che hanno tutti bisogno dello stesso archivio dei poli.

Flusso di lavoro AI bootstrap

Genera lo schema dell'archivio e il piano di integrazione da un singolo prompt strutturato.

Pronto a lanciare la tua app di archivio lampioni?

Lascia che l'Agente AI di Back4app scaffolding il tuo backend dell'archivio lampioni e generi il tracciamento dei tipi di lampadine, i registri dei ballast e la storia della manutenzione da un prompt.

Costruisci con l'Agente AI Prova l'API Playground

Gratis per iniziare — 50 prompt dell'Agente AI/mese, senza necessità di carta di credito

Stack Tecnico

Tutto incluso in questo modello backend dell'archivio dei pali di illuminazione stradale.

Frontend

13+ tecnologie

Backend

Back4app

Database

MongoDB

Auth

Autenticazione e sessioni integrate

API

REST e GraphQL

In tempo reale

Live Queries

Diagramma ER del palo

Modello di relazione tra entità per lo schema dell'archivio dei pali delle lampade stradali.

Diagramma ER

Visualizza sorgente del diagramma

Mermaid

erDiagram
    Operator ||--o{ Pole : "assignedOperator"
    Operator ||--o{ BulbRecord : "createdBy"
    Operator ||--o{ BallastLog : "inspectedBy"
    Operator ||--o{ MaintenanceEntry : "performedBy"
    Pole ||--o{ BulbRecord : "pole"
    Pole ||--o{ BallastLog : "pole"
    Pole ||--o{ MaintenanceEntry : "pole"

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

    Pole {
        String objectId PK
        String poleNumber
        String locationLabel
        String bulbType
        Date lastBallastCheckAt
        String status
        String assignedOperatorId FK
        Date createdAt
        Date updatedAt
    }

    BulbRecord {
        String objectId PK
        String poleId FK
        String bulbType
        Date installedAt
        String notes
        String createdById FK
        Date createdAt
        Date updatedAt
    }

    BallastLog {
        String objectId PK
        String poleId FK
        Date inspectionDate
        String ballastCondition
        String actionTaken
        String inspectedById FK
        Date createdAt
        Date updatedAt
    }

    MaintenanceEntry {
        String objectId PK
        String poleId FK
        Date workDate
        String taskType
        String summary
        Boolean resolved
        String performedById FK
        Date createdAt
        Date updatedAt
    }

Flusso di integrazione dell'archivio

Flusso di esecuzione tipico per autenticazione, ricerca dei pali, aggiornamenti del tipo di lampadina, registri dei ballasts e storicizzazione della manutenzione.

Diagramma ER

Visualizza sorgente del diagramma

Mermaid

sequenceDiagram
  participant User
  participant App as Streetlight Pole Archive App
  participant Back4app as Back4app Cloud

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

  User->>App: Open pole archive
  App->>Back4app: GET /classes/Pole?include=assignedOperator
  Back4app-->>App: Pole list with bulbType and status

  User->>App: Add bulb record or ballast log
  App->>Back4app: POST /classes/BulbRecord
  App->>Back4app: POST /classes/BallastLog
  Back4app-->>App: Saved record IDs

  User->>App: Record maintenance history
  App->>Back4app: POST /classes/MaintenanceEntry
  Back4app-->>App: Maintenance entry saved

  App->>Back4app: Subscribe to live updates for Pole and MaintenanceEntry
  Back4app-->>App: Live query changes

Dizionario dei campi

Riferimento completo a livello di campo per ogni classe nello schema dell'archivio dei lampioni.

Campo	Tipo	Descrizione	Obbligatorio
objectId	String	Auto-generated unique identifier	Auto
username	String	Login name for managers and field staff
email	String	Work email address
password	String	Hashed password (write-only)
role	String	Access role such as coordinator, inspector, or admin
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

7 campi in Operator

Sicurezza e permessi

Come la strategia ACL e CLP protegge i pali, i tipi di lampadine, i registri dei ballasts e la cronologia della manutenzione.

Modifiche all'archivio consapevoli del ruolo

Solo i coordinatori o i tecnici autorizzati possono creare o modificare registri di Pole, BallastLog e MaintenanceEntry.

Integrità della cronologia

Usa Cloud Code per convalidare i ballasts e le voci di manutenzione prima di salvarli nella cronologia dell'archivio di un palo.

Accesso in lettura scopo

Limita le letture dell'archivio per distretto, squadra o ordine di lavoro in modo che gli utenti sul campo vedano solo i pali di cui hanno bisogno.

Schema Archivio JSON

Definizione JSON schema grezza pronta da copiare in Back4app o utilizzare come riferimento per l'implementazione.

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

{
  "classes": [
    {
      "className": "Operator",
      "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": "Pole",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "poleNumber": {
          "type": "String",
          "required": true
        },
        "locationLabel": {
          "type": "String",
          "required": true
        },
        "bulbType": {
          "type": "String",
          "required": true
        },
        "lastBallastCheckAt": {
          "type": "Date",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "assignedOperator": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Operator"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "BulbRecord",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "pole": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Pole"
        },
        "bulbType": {
          "type": "String",
          "required": true
        },
        "installedAt": {
          "type": "Date",
          "required": true
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Operator"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "BallastLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "pole": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Pole"
        },
        "inspectionDate": {
          "type": "Date",
          "required": true
        },
        "ballastCondition": {
          "type": "String",
          "required": true
        },
        "actionTaken": {
          "type": "String",
          "required": true
        },
        "inspectedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Operator"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "MaintenanceEntry",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "pole": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Pole"
        },
        "workDate": {
          "type": "Date",
          "required": true
        },
        "taskType": {
          "type": "String",
          "required": true
        },
        "summary": {
          "type": "String",
          "required": true
        },
        "resolved": {
          "type": "Boolean",
          "required": true
        },
        "performedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Operator"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Costruisci con AI Agent

Utilizza l'AI Agent di Back4app per generare un'app archivio pali stradali reale da questo modello, inclusi frontend, backend, autenticazione, e flussi di log di pali, tipo di lampadina, ballast e storia della manutenzione.

Back4app AI Agent

Pronto per costruire

Crea un'app backend per l'archivio dei pali della luce su Back4app con questo schema e comportamento esatti.

Schema:
1. Utente (usa Back4app integrato): nome utente, email, password; objectId, createdAt, updatedAt (sistema).
2. Pali: codicePalo (String, richiesto), nomePosizione (String, richiesto), tipoPalo (String, richiesto), stato (String, richiesto), tipoLampadina (Puntatore a TipoLampadina, facoltativo), logBallast (Puntatore a LogBallast, facoltativo); objectId, createdAt, updatedAt (sistema).
3. TipoLampadina: nome (String, richiesto), tecnologia (String, richiesto), wattaggio (Number, richiesto), oreVita (Number, facoltativo), note (String, facoltativo); objectId, createdAt, updatedAt (sistema).
4. LogBallast: palo (Puntatore a Palo, richiesto), modelloBallast (String, richiesto), dataServizio (Date, richiesto), notaTecnico (String, facoltativo), sostituito (Boolean, richiesto); objectId, createdAt, updatedAt (sistema).
5. VoceManutenzione: palo (Puntatore a Palo, richiesto), tipoAzione (String, richiesto), eseguitaIl (Date, richiesto), risultato (String, richiesto), nomeTecnico (String, facoltativo); objectId, createdAt, updatedAt (sistema).

Sicurezza:
- Solo gli utenti autorizzati possono creare o aggiornare le voci dell'archivio dei pali. Usa Cloud Code per convalidare la scrittura della storia dei pali.

Auth:
- Registrazione, accesso, disconnessione.

Comportamento:
- Elenca i pali, rivedi i dettagli del tipo di lampadina, aggiungi log di ballast e aggiungi la storia della manutenzione.

Consegna:
- App Back4app con schema, ACL, CLP; frontend per pali, tipi di lampadina, log di ballast e storia della manutenzione.

Premi il pulsante qui sotto per aprire l'Agent con questo prompt del modello già compilato.

Questo è il prompt base senza suffisso tecnologico. Puoi adattare il stack frontend generato in seguito.

Distribuisci in pochi minuti50 prompt gratuiti al meseNessuna carta di credito richiesta

API Playground

Prova REST e gli endpoint di GraphQL contro lo schema dell'archivio dei pali della luce. Le risposte utilizzano dati fittizi e non richiedono un account Back4app.

Caricamento del playground…

Utilizza lo stesso schema di questo modello.

Scegli la tua tecnologia

Espandi ogni scheda per vedere come integrare Pole, BulbType e BallastLog con il tuo stack scelto.

Cosa ottieni con ogni tecnologia

Ogni stack utilizza lo stesso schema di archivio dei lampioni e contratti API.

Struttura dei dati dell'archivio dei pali unificata

Gestisci Pole, BulbType, BallastLog e MaintenanceEntry con uno schema coerente.

Ricerche sui tipi di lampadine per le squadre sul campo

Mostra tecnologia della lampadina, wattaggio e ore di vita quando un palo è aperto.

Storia di Ballast e manutenzione

Mantieni note di servizio collegate allo stesso palo in modo che il lavoro di follow-up sia facile da tracciare.

Flussi di lavoro di archiviazione basati sul ruolo

Separa le azioni del coordinatore dalle azioni del tecnico con autorizzazioni e Cloud Code.

Accesso REST/GraphQL per ogni cliente

Collega dashboard, moduli mobili e strumenti di reporting allo stesso backend di archiviazione.

Confronto del Framework Archive Streetlight

Confronta la velocità di configurazione, lo stile degli SDK e il supporto AI tra tutte le tecnologie supportate.

Framework	Tempo di Configurazione	Archivio Vantaggio	Tipo di SDK	Supporto AI
Flutter	Circa 5 min	Codice sorgente unico per le app di archivio degli uffici e dei poli.	SDK Tipizzato	Completo
React	Meno di 5 minuti	Dashboard web veloce per l'inventario e i registri dei poli.	SDK Tipizzato	Completo
React Nativo	~3–7 min	App mobile multipiattaforma per ispezioni e cronologia della manutenzione.	SDK Tipizzato	Completo
Next.js	Impostazione rapida (5 min)	Portale archivio renderizzato dal server per coordinatori.	SDK tipizzato	Completo
JavaScript	~3-5 min	Integrazione web leggera per schermi di ricerca di pali.	SDK tipizzato	Completo
Android	Circa 5 min	App nativa Android per le squadre sul campo.	SDK tipizzato	Completo
iOS	Meno di 5 minuti	App nativa iOS per ispezioni e note di servizio.	SDK digitato	Completo
Vue	~3–7 min	Interfaccia web Reactive per la navigazione dell'archivio.	SDK digitato	Completo
Angular	Installazione rapida (5 min)	Console operativa enterprise per la gestione dei pali.	SDK digitato	Completo
GraphQL	Meno di 2 min	API flessibile di GraphQL per query di archiviazione nidificate.	GraphQL API	Completo
REST API	Impostazione rapida (2 min)	Integrazione di REST API per strumenti di servizio e dashboard.	REST API	Completo
PHP	~3 min	Backend PHP lato server per portali di archiviazione.	REST API	Completo
.NET	~3–7 min	.NET backend per i sistemi operativi.	SDK tipizzato	Completo

Il tempo di configurazione riflette la durata prevista dal bootstrap del progetto alla prima query di Pole o MaintenanceEntry utilizzando questo schema di template.

Domande Frequenti

Domande comuni sulla creazione di un backend per l'archivio dei poli delle lampade stradali con questo template.

Come appare una traccia di audit credibile dell'archivio dei lampioni da cima a fondo?

Come catturano i programmi di archivio dei lampioni formazione, attestazioni e azioni correttive in modo pulito?

Qual è il percorso consigliato per restringere i permessi dell'archivio dei lampioni man mano che l'organizzazione cresce?

Come posso interrogare i dettagli del palo in Flutter?

Come costruisco un dashboard di Next.js per la storia della manutenzione?

Può React memorizzare localmente i record dei pali?

Come posso fermare modifiche non autorizzate alle voci di manutenzione?

Qual è il modo migliore per mostrare i dati del tipo di lampadina su Android?

Affidato da sviluppatori in tutto il mondo

Unisciti ai team che spediscano prodotti archiviati più velocemente con i template di Back4app

Pronto a costruire la tua app di archivio per pali di illuminazione?

Inizia il tuo progetto di archivio per pali in pochi minuti. Nessuna carta di credito necessaria.

Scegli tecnologia

Modello del backend dell'archivio dei pali della luce stradaleInventario dei pali, tracciamento dei tipi di lampadine e storia della manutenzione