Backend per Audit di Rilevatori di Fumi

Modello di Backend per Audit di Rilevatori di Fumi
Registri di Sostituzione Batteria e Mappe di Test del Sito

Q: Quali classi alimentano il modello di Audit del Rilevatore di Fumi?

Il modello di base include Utente, Sito, Rilevatore, RegistroBatteria, TestSensibilità e MappaPinn. Queste classi mantengono le ispezioni legate a una posizione, un numero di serie del rilevatore e il lavoro svolto.

Q: Come registrare la sostituzione di una batteria per un rilevatore?

Crea un'entrata RegistroBatteria con il puntatore del rilevatore, la data di sostituzione, il tipo di batteria e la nota del tecnico. I manager possono successivamente rivedere la storia della batteria per un determinato Rilevatore.numeroDiSerie.

Q: Come si inseriscono i test di sensibilità nel flusso di audit?

Utilizza TestSensibilità per memorizzare testatoIl, risultato e valoreDiLettura opzionale per ogni rilevatore. Un risultato fallito può attivare una visita di follow-up presso il Sito correlato.

Q: Come funzionano gli aggiornamenti in tempo reale per i percorsi di audit?

Iscriviti ai cambiamenti di MappaPinn e TestSensibilità con Live Queries così che il dashboard si aggiorni quando un lavoratore sul campo termina un sito o cambia lo stato di un rilevatore.

Q: Posso memorizzare offline i siti e i rilevatori?

Sì. Abilita il DataStore Locale e fissa i risultati di Sito e Rilevatore affinché un lavoratore sul campo possa rivedere indirizzi e numeri di serie anche quando il segnale si interrompe.

Q: Come posso inizializzare l'SDK per questo modello in React?

Usa il frammento di avvio rapido React per impostare le chiavi dell'app Back4app, quindi interroga le classi Site e Detector per l'elenco degli audit attuali.

Q: Quando dovrei scegliere GraphQL rispetto a REST per gli audit dei rivelatori di fumo?

Scegli GraphQL se il tuo schermo ha bisogno di dati nested di Site, Detector e BatteryLog in una sola richiesta; utilizza REST quando desideri endpoint di classe diretti per strumenti più semplici.

Q: Quali stack mobili funzionano meglio con i controlli offline del rivelatore?

Flutter, React Native, Android e iOS possono memorizzare localmente i dati di Site, Detector, BatteryLog e SensitivityTest e sincronizzare i record dopo la riconnessione.

Q: Come posso impedire a qualcuno di modificare il registro delle batterie di un altro tecnico?

Usa ACL e Cloud Code in modo che solo l'utente autenticato che ha creato un BatteryLog possa aggiornarlo, mentre i manager mantengono accesso alla revisione.

Q: Cosa succede quando un rivelatore fallisce il test di sensibilità?

Segna il Detector.status come needs_attention, memorizza un risultato di SensitivityTest fallito e tieni la prossima visita legata allo stesso Site in modo che la squadra sappia dove tornare.

Un backend di audit del rilevatore di fumi pronto per la produzione su Back4app con registri di sostituzione della batteria, test di sensibilità e pin delle mappe per i percorsi di ispezione. Include diagramma ER, dizionario dei dati, schema JSON, playground API e un prompt AI Agent per una configurazione rapida.

Costruisci con AI Agent Scegli la tua tecnologia

Riepiloghi dell'audit

Questo modello ti fornisce un backend di audit per rilevatori di fumo con registri di sostituzione delle batterie, test di sensibilità e mappe del sito, in modo che i coordinatori e il personale di campo possano tenere traccia delle ispezioni con meno lavoro manuale.

Storico delle sostituzioni della batteria — Registra ogni voce di `BatteryLog` con numeri di serie dei rilevatori, date di cambio e note dei tecnici.
Test di sensibilità per rilevatore — Memorizza i risultati di `SensitivityTest` per ogni `Detector` in modo che i controlli falliti siano facili da individuare e seguire.
Tracciamento del sito pronto per la mappa — Utilizza i record di `Site` e `MapPin` per posizionare i rilevatori sulle mappe e pianificare le visite sul campo.

Che cos'è il Modello di Audit dei Rilevatori di Fumo?

Quando i team di audit dei rilevatori di fumo operano su più siti, una tassonomia uniforme previene il problema di avere “stesso problema, cinque nomi diversi” nella cronologia dell'audit. La soluzione è operativa, non motivazionale. Back4app mantiene il Sito, il Rilevatore, il Registro della Batteria, il Test di Sensibilità e la Mappa Pin con timestamp e attribuibili — ciò che i team di audit dei rilevatori di fumo necessitano quando arriva il controllo. Lo schema include Utente (nome utente, email, password), Sito (nome, indirizzo, posizione sulla mappa), Rilevatore (sito, numero di serie, stato), Registro della Batteria (rilevatore, sostituitoIl, tipoDiBatteria), Test di Sensibilità (rilevatore, testatoIl, risultato) e Mappa Pin (sito, latitudine, longitudine) con autenticazione, reportistica e registrazioni compatibili con la mappa integrate. Collega il tuo frontend e inizia a tracciare gli audit più velocemente.

Migliore per:

App di ispezione dei rilevatori di fumoStrumenti di registro della sostituzione della batteriaTracciamento del test di sensibilitàSistemi di audit sul campo basati su mappaCoordinatori della manutenzioneTeam operativi con visite ricorrenti sul sito

Panoramica del backend per l'audit dei rilevatori di fumo

Gli operatori nell'audit dei rilevatori di fumo di solito avvertono il dolore prima nei passaggi: un team aggiorna un foglio, un altro si fida di una chat, e nessuno corrisponde a quanto detto al cliente.

Che tu spediscas web o mobile, Sito, Rilevatore e BatteryLog rimangono la spina dorsale — questa pagina è il modo più veloce per allineare le parti interessate.

Funzionalità principali di audit del rilevatore di fumi

Ogni scheda tecnologica in questo hub utilizza lo stesso schema di audit del rivelatore di fumi con Sito, Rivelatore, BatteryLog, SensitivityTest e MapPin.

Registro dei siti e ancore sulla mappa

`Site` memorizza nome, indirizzo e mapLocation per ogni edificio o pianta.

Inventario dei detector

`Detector` collega serialNumber, status e site.

Log di sostituzione della batteria

`BatteryLog` memorizza replacedAt, batteryType e technicianNote.

Risultati del test di sensibilità

`SensitivityTest` registra testedAt, result e detector.

Posizionamento del pin della mappa

`MapPin` utilizza latitudine, longitudine e sito.

Perché costruire il tuo backend di audit dei rilevatori di fumo con Back4app?

Back4app ti offre siti, rilevatori e primitive di audit in modo che il tuo team possa concentrarsi su batterie, test e pianificazione dei percorsi invece che sulla parte backend.

•Registrazioni di rilevatori e siti in un unico posto: La classe `Detector` è collegata a `Site`, in modo che i controlli delle batterie e i test di sensibilità rimangano legati all'indirizzo corretto e al pin della mappa.
•Storia del registro delle batterie facile da interrogare: Le righe di `BatteryLog` catturano `replacedAt`, `batteryType` e `technicianNote`, che aiutano i manager a rivedere il lavoro di sostituzione per rilevatore o data.
•Stato live per ispezioni e modifiche del percorso: Usa Live Queries per gli aggiornamenti di `SensitivityTest` e `MapPin` mantenendo REST e GraphQL pronti per dashboard web e strumenti mobili di campo.

Crea il backend di audit una volta, poi riutilizza le stesse classi per la pianificazione del percorso, la cronologia delle ispezioni e il lavoro di follow-up.

Vantaggi principali

Un backend di audit del rivelatore di fumi che aiuta i team a rimanere organizzati senza perdere i dettagli che contano.

Aggiornamenti di campo più rapidi

Scrivi voci di `BatteryLog` e `SensitivityTest` man mano che si verificano le visite invece di aspettare una pulizia del foglio di calcolo.

Cancella la cronologia del rivelatore

Usa `Detector.serialNumber` più log collegati per rivedere la cronologia della manutenzione per qualsiasi unità.

Pianificazione basata su mappa

`Site.mapLocation` e `MapPin.latitude` / `MapPin.longitude` rendono la pianificazione del percorso meno un'ipotesi.

Migliore follow-up sui test falliti

Un `SensitivityTest.result` fallito può essere filtrato immediatamente in modo che i supervisori sappiano quale rivelatore necessita di attenzione.

Un backend per mobile e desktop

REST e GraphQL espongono gli stessi dati di `Site`, `Detector`, e log a tutte le app che ne hanno bisogno.

Impostazione riutilizzabile per future verifiche

Aggiungi campi extra in seguito, ma mantieni lo stesso schema di base attorno a `BatteryLog` e `SensitivityTest`.

Pronto a lanciare la tua app di verifica del rilevatore di fumi?

Lascia che l'agente AI di Back4app scaffodi il tuo backend di verifica e generi log della batteria, test di sensibilità e viste mappa da un solo prompt.

Costruisci con AI Agent Prova l'API Playground

Gratis per iniziare — 50 prompt AI Agent/mese, senza carta di credito richiesta

Stack Tecnico

Tutto incluso in questo modello di audit del rilevatore di fumo.

Frontend

13+ tecnologie

Backend

Back4app

Database

MongoDB

Auth

Autenticazione integrata + sessioni

API

REST e GraphQL

In tempo reale

Live Queries

Diagramma ER Audit fumi

Modello di relazione tra entità per lo schema del backend dell'audit del rivelatore di fumi.

Diagramma ER

Visualizza origine del diagramma

Mermaid

erDiagram
    Inspector ||--o{ Building : "primaryCoordinator"
    Inspector ||--o{ Audit : "inspector"
    Inspector ||--o{ BatteryReplacement : "replacedBy"
    Inspector ||--o{ SensitivityTest : "testedBy"
    Building ||--o{ Detector : "building"
    Building ||--o{ Audit : "building"
    Building ||--o{ SiteMap : "building"
    Detector ||--o{ BatteryReplacement : "detector"
    Detector ||--o{ SensitivityTest : "detector"

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

    Building {
        String objectId PK
        String buildingName
        String address
        String city
        String state
        Number latitude
        Number longitude
        String primaryCoordinatorId FK
        Date createdAt
        Date updatedAt
    }

    Detector {
        String objectId PK
        String buildingId FK
        String roomLabel
        String deviceId
        String modelNumber
        Number batteryLevel
        Date lastBatteryChangeAt
        String status
        Date createdAt
        Date updatedAt
    }

    Audit {
        String objectId PK
        String buildingId FK
        String inspectorId FK
        Date auditDate
        String overallStatus
        String notes
        Date createdAt
        Date updatedAt
    }

    BatteryReplacement {
        String objectId PK
        String detectorId FK
        String replacedById FK
        Date replacementDate
        String batteryType
        String oldBatteryCondition
        Date createdAt
        Date updatedAt
    }

    SensitivityTest {
        String objectId PK
        String detectorId FK
        String testedById FK
        Date testDate
        String testResult
        Number readingValue
        String notes
        Date createdAt
        Date updatedAt
    }

    SiteMap {
        String objectId PK
        String buildingId FK
        String mapName
        Number floorNumber
        String mapUrl
        String legendNotes
        Date createdAt
        Date updatedAt
    }

Flusso di integrazione dell'audit

Flusso di esecuzione tipico per autenticazione, ricerca del sito, registri della batteria, test di sensibilità e aggiornamenti della mappa.

Diagramma ER

Visualizza origine del diagramma

Mermaid

sequenceDiagram
  participant Inspector
  participant App as Smoke Detector Audit App
  participant Back4app as Back4app Cloud

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

  Inspector->>App: Open building list
  App->>Back4app: GET /classes/Building?include=primaryCoordinator
  Back4app-->>App: Buildings and coordinators

  Inspector->>App: Review detector batteries
  App->>Back4app: GET /classes/Detector?include=building&order=-updatedAt
  Back4app-->>App: Detector battery levels and statuses

  Inspector->>App: Save a battery replacement or sensitivity test
  App->>Back4app: POST /classes/BatteryReplacement
  App->>Back4app: POST /classes/SensitivityTest
  Back4app-->>App: Saved audit trail records

  Inspector->>App: Load site maps for a building
  App->>Back4app: GET /classes/SiteMap?include=building
  Back4app-->>App: Floor plans and detector locations

Dizionario dei dati dell'audit

Riferimento completo a livello di campo per ogni classe nello schema dell'audit del rilevatore di fumi.

Campo	Tipo	Descrizione	Richiesto
objectId	String	Auto-generated unique identifier	Auto
username	String	Inspector login name
email	String	Inspector email address
password	String	Hashed password (write-only)
role	String	Role of the user (e.g., manager, coordinator, field_tech)
phoneNumber	String	Contact number for site coordination	—
createdAt	Date	Auto-generated creation timestamp	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

8 campi in Inspector

Sicurezza e Permessi

Come la strategia ACL e CLP protegge i record del sito, le cronologie dei rilevatori e i registri di audit.

Voci di audit di proprietà del tecnico

Solo l'utente che ha creato una voce di `BatteryLog` o `SensitivityTest` dovrebbe essere in grado di modificarla o eliminarla.

Accesso in lettura a livello di sito

Limitare la visibilità di `Site` e `Detector` al personale o ai ruoli di gestione assegnati quando un percorso di audit è condiviso.

Cambia il controllo per lo stato del rivelatore

Utilizza il Cloud Code per convalidare le transizioni di `Detector.status` in modo che i test o le sostituzioni non riusciti siano registrati correttamente.

Schema (JSON)

Definizione dello schema JSON grezzo pronta per essere copiata in Back4app o utilizzata 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

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

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

{
  "classes": [
    {
      "className": "Inspector",
      "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
        },
        "phoneNumber": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Building",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "buildingName": {
          "type": "String",
          "required": true
        },
        "address": {
          "type": "String",
          "required": true
        },
        "city": {
          "type": "String",
          "required": true
        },
        "state": {
          "type": "String",
          "required": true
        },
        "latitude": {
          "type": "Number",
          "required": false
        },
        "longitude": {
          "type": "Number",
          "required": false
        },
        "primaryCoordinator": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Inspector"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Detector",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "building": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Building"
        },
        "roomLabel": {
          "type": "String",
          "required": true
        },
        "deviceId": {
          "type": "String",
          "required": true
        },
        "modelNumber": {
          "type": "String",
          "required": true
        },
        "batteryLevel": {
          "type": "Number",
          "required": false
        },
        "lastBatteryChangeAt": {
          "type": "Date",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Audit",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "building": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Building"
        },
        "inspector": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Inspector"
        },
        "auditDate": {
          "type": "Date",
          "required": true
        },
        "overallStatus": {
          "type": "String",
          "required": true
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "BatteryReplacement",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "detector": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Detector"
        },
        "replacedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Inspector"
        },
        "replacementDate": {
          "type": "Date",
          "required": true
        },
        "batteryType": {
          "type": "String",
          "required": true
        },
        "oldBatteryCondition": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "SensitivityTest",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "detector": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Detector"
        },
        "testedBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Inspector"
        },
        "testDate": {
          "type": "Date",
          "required": true
        },
        "testResult": {
          "type": "String",
          "required": true
        },
        "readingValue": {
          "type": "Number",
          "required": false
        },
        "notes": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "SiteMap",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "building": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Building"
        },
        "mapName": {
          "type": "String",
          "required": true
        },
        "floorNumber": {
          "type": "Number",
          "required": false
        },
        "mapUrl": {
          "type": "String",
          "required": true
        },
        "legendNotes": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Costruisci con l'agente AI

Utilizza l'agente AI di Back4app per generare un'app di audit del rivelatore di fumo reale da questo template, inclusi frontend, backend, autenticazione e flussi di batteria, test e mappa.

Back4app Agente AI

Pronto per costruire

Crea un backend dell'app per l'audit dei rilevatori di fumo su Back4app con questo schema e comportamento esatti.

Schema:
1. Utente (usa il Back4app integrato): nome utente, email, password; objectId, createdAt, updatedAt (sistema).
2. Sito: nome (String, obbligatorio), indirizzo (String, obbligatorio), mappa posizione (GeoPoint, obbligatorio), note (String); objectId, createdAt, updatedAt (sistema).
3. Rilevatore: sito (Puntatore al Sito, obbligatorio), numero di serie (String, obbligatorio, unico), stato (String, obbligatorio), nome modello (String), ultimo cambio batteria (Date); objectId, createdAt, updatedAt (sistema).
4. RegistroBatteria: rilevatore (Puntatore al Rilevatore, obbligatorio), sostituito il (Date, obbligatorio), tipo di batteria (String, obbligatorio), nota del tecnico (String), sostituito da (Puntatore all'Utente); objectId, createdAt, updatedAt (sistema).
5. TestSensibilità: rilevatore (Puntatore al Rilevatore, obbligatorio), testato il (Date, obbligatorio), risultato (String, obbligatorio), valore di lettura (Number), nota del tecnico (String); objectId, createdAt, updatedAt (sistema).
6. MappaPin: sito (Puntatore al Sito, obbligatorio), latitudine (Number, obbligatorio), longitudine (Number, obbligatorio), etichetta (String), ordine percorso (Number); objectId, createdAt, updatedAt (sistema).

Sicurezza:
- Usa ACL/CLP in modo che i tecnici possano scrivere i propri registri di Batteria e Test di Sensibilità, mentre i manager possono esaminare la cronologia di sito e rilevatori.
- Usa Cloud Code per convalidare le modifiche di stato dei rilevatori e richiedere i dati del sito collegato.

Autenticazione:
- Registrazione, accesso, disconnessione.

Comportamento:
- Elenca i siti, mostra i rilevatori per sito, crea registri di sostituzione delle batterie, invia test di sensibilità e aggiorna le pin della mappa per il prossimo percorso.

Consegna:
- App Back4app con schema, ACL, CLP; frontend per siti, rilevatori, registri batteria, test di sensibilità e viste mappa.

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

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

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

API Playground

Prova REST e i punti finali di GraphQL contro lo schema di audit dei rilevatori di fumo. Le risposte utilizzano dati fittizi e non richiedono un account Back4app.

Caricamento playground…

Utilizza lo stesso schema di questo modello.

Scegli la tua tecnologia

Espandi ogni scheda per vedere come integrare Site, Detector e BatteryLog con il tuo stack scelto.

Cosa Ottieni con Ogni Tecnologia

Ogni stack utilizza lo stesso schema di backend dell'audit del rivelatore di fumi e contratti API.

Struttura dati di audit unificata

Gestisci siti, rivelatori, log delle batterie, test di sensibilità e pin della mappa con uno schema coerente.

Log di sostituzione delle batterie per i team di campo

Monitora ogni cambio di batteria con un timestamp, puntatore del rivelatore e nota del tecnico.

Monitoraggio dei test di sensibilità per verifiche di conformità

Registra i risultati di passaggio o fallimento per rilevatore in modo che il lavoro di follow-up sia ovvio.

Pianificazione del sito consapevole della mappa

Utilizza le coordinate del sito e registra i pin per pianificare i percorsi e ridurre le ispezioni mancate.

REST/GraphQL API per app di audit

Integra strumenti web, mobili e interni attraverso un contratto di backend unico.

Confronto Tecnico Audit Fumi

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

Framework	Tempo di configurazione	Vantaggio di audit	Tipo di SDK	Supporto AI
Flutter	Circa 5 min	Base di codice unica per audit di campo su mobile e web.	SDK digitato	Completo
React	Meno di 5 minuti	Dashboard web veloce per la cronologia dei rilevatori.	SDK Digitato	Completo
React Nativo	~3–7 min	App mobile multipiattaforma per registri della batteria.	SDK Digitato	Completo
Next.js	Impostazione rapida (5 min)	Mappa del sito e dashboard di audit renderizzate dal server.	SDK Digitato	Completo
JavaScript	~3–5 min	Integrazione del browser leggera per i moduli di ispezione.	SDK Digitato	Completo
Android	Circa 5 min	App nativa Android per controlli in loco.	SDK tipizzato	Completo
iOS	Meno di 5 minuti	App nativa per iPhone per i flussi di lavoro dei tecnici.	SDK tipizzato	Completo
Vue	~3–7 min	Interfaccia web Reactive per mappe del sito.	SDK tipizzato	Completo
Angular	Impostazione rapida (5 min)	Portale di audit aziendale per i team operativi.	SDK digitato	Completo
GraphQL	Meno di 2 min	API flessibile GraphQL per i dati del rilevatore annidato.	API GraphQL	Completo
REST API	Impostazione rapida (2 min)	Integrazione REST API per l'invio dei log.	REST API	Completo
PHP	~3 min	Backend di PHP lato server per strumenti di amministrazione dell'audit.	REST API	Completo
.NET	~3–7 min	Backend di .NET per flussi di lavoro di ispezione dei rilevatori.	SDK tipizzato	Completo

Il tempo di configurazione riflette la durata prevista dal bootstrap del progetto alla prima query del sito, del rilevatore o del log utilizzando questo schema di template.

Domande Frequenti

Domande comuni sulla creazione di un backend per l'audit dei rilevatori di fumi con questo modello.

Quali classi alimentano il modello di Audit del Rilevatore di Fumi?

Come registrare la sostituzione di una batteria per un rilevatore?

Come si inseriscono i test di sensibilità nel flusso di audit?

Come funzionano gli aggiornamenti in tempo reale per i percorsi di audit?

Posso memorizzare offline i siti e i rilevatori?

Come posso inizializzare l'SDK per questo modello in React?

Quando dovrei scegliere GraphQL rispetto a REST per gli audit dei rivelatori di fumo?

Quali stack mobili funzionano meglio con i controlli offline del rivelatore?

Come posso impedire a qualcuno di modificare il registro delle batterie di un altro tecnico?

Cosa succede quando un rivelatore fallisce il test di sensibilità?

Affidato a sviluppatori in tutto il mondo

Unisciti ai team che lanciano più velocemente prodotti di audit per rilevatori di fumo con i modelli di Back4app

Pronto per costruire la tua app di audit per rilevatori di fumo?

Inizia il tuo progetto di audit per rilevatori di fumo in pochi minuti. Nessuna carta di credito richiesta.

Scegli la tecnologia

Modello di Backend per Audit di Rilevatori di FumiRegistri di Sostituzione Batteria e Mappe di Test del Sito