Schichtplanung
Mit AI-Agent bauen
Schichtplanungs-Backend

Schichtplanungs-App-Backend-Vorlage
Dienstplanverwaltung und geofencing-gestützte Zeiterfassung

Ein produktionsbereites Schichtplanungs-Backend auf Back4app mit Benutzern, Schichten und Plänen. Enthält ER-Diagramm, Datenwörterbuch, JSON-Schema, API-Spielplatz und einen KI-Agent-Prompt für schnelles Bootstrap.

Mit AI-Agent bauenWählen Sie Ihre Technologie

Wichtige Erkenntnisse

Diese Vorlage bietet ein Schichtplanungs-Backend mit Benutzern, Schichten und Plänen, damit sich Ihr Team auf effizientes Schichtmanagement und Zeiterfassung konzentrieren kann.

  1. Benutzerzentriertes Planungsdesign — Modellieren Sie Benutzer mit Schichten und Plänen in klaren, abfragbaren Strukturen.
  2. Echtzeit-Planungsaktualisierungen — Nutzen Sie die Echtzeit-Fähigkeiten von Back4app für Schichtänderungen und Benachrichtigungen.
  3. Geofencing-Zeiterfassung — Sorgen Sie für eine genaue Zeiterfassung mit geofenced Ein- und Ausstempelfunktionen.
  4. Schichttausch-Logik — Ermöglichen Sie Benutzern, Schichten nahtlos mit Genehmigungs-Workflows zu tauschen.
  5. Plattformübergreifendes Planungs-Backend — Bedienen Sie mobile und Web-Clients über eine einzige REST- und GraphQL-API für Benutzer, Schichten und Zeitpläne.

Was ist die Schichtplanungs-App-Backend-Vorlage?

Back4app ist ein Backend-as-a-Service (BaaS) für schnelle Produktauslieferung. Die Schichtplanungs-App-Backend-Vorlage ist ein vorgefertigtes Schema für Benutzer, Schichten und Zeitpläne. Verbinden Sie Ihr bevorzugtes Frontend (React, Flutter, Next.js und mehr) und liefern Sie schneller aus.

Am besten geeignet für:

SchichtplanungsanwendungenPlattformen für das Workforce-ManagementApps zur Zeiterfassung und AnwesenheitskontrolleMobile-First-Planungs-AppsMVP-EinführungenTeams, die BaaS für Planungsprodukte auswählen

Übersicht

Ein Schichtplanungsprodukt benötigt Benutzerprofile, Schichten, Zeitpläne und Zeiterfassung.

Diese Vorlage definiert Benutzer, Schicht und Zeitplan mit Echtzeitfunktionen und Eigentumsregeln, damit Teams Planungsinteraktionen schnell implementieren können.

Kernfunktionen der Schichtplanung

Jede Technologiekarte in diesem Hub verwendet dasselbe Schichtplanungs-Backend-Schema mit Benutzer, Schicht und Zeitplan.

Benutzerprofile und Rollen

Die Benutzerklasse speichert Benutzername, E-Mail, Passwort und Rolle.

Schichterstellung und -verwaltung

Die Schichtklasse verknüpft Benutzer, Startzeit, Endzeit und Ort.

Planung und Zeiterfassung

Die Schedule-Klasse speichert Benutzerreferenzen und zugehörige Schichten.

Schichttausch

Unterstützung von Schichttausch mit Genehmigungs-Workflows.

Echtzeit-Benachrichtigungen

Benachrichtigen Sie Benutzer über Planänderungen und Schichtaktualisierungen.

Warum sollten Sie Ihr Schichtplanungs-Backend mit Back4app erstellen?

Back4app bietet Ihnen Benutzer-, Schicht- und Planungsgrundlagen, damit Ihr Team sich auf effiziente Planung und Zeitmanagement konzentrieren kann, anstatt auf Infrastruktur.

  • •Benutzer- und Schichtverwaltung: Benutzerklasse mit Rollenfeldern und Schichtklasse für die Planungsverwaltung unterstützt effiziente Schichtoperationen.
  • •Geofenced-Zeitstempeln: Sorgen Sie für eine genaue Zeiterfassung mit geofenced Ein- und Ausstempelfunktionen.
  • •Echtzeit + API-Flexibilität: Verwenden Sie Live Queries für Planungsaktualisierungen, während REST und GraphQL für jeden Kunden verfügbar bleiben.

Entwickeln und iterieren Sie schnell an Planungsfunktionen mit einem Backend-Vertrag über alle Plattformen hinweg.

Kernvorteile

Ein Planungs-Backend, das Ihnen hilft, schnell zu iterieren, ohne die Struktur zu opfern.

Schneller Start der Planung

Beginnen Sie mit einem vollständigen Benutzer-, Schicht- und Zeitplanschema, anstatt das Backend von Grund auf neu zu entwerfen.

Echtzeit-Planungsunterstützung

Nutzen Sie Echtzeitbenachrichtigungen und -aktualisierungen für ein verbessertes Benutzerengagement.

Flexibles Schichtmanagement

Verwalten Sie Schichten mit Austausch- und Genehmigungsworkflows für Flexibilität.

Skalierbares Berechtigungsmodell

Verwenden Sie ACL/CLP, damit nur Benutzer ihre Zeitpläne und Schichten bearbeiten und Tauschanfragen verwalten können.

Genaues Zeit-Tracking

Verwenden Sie Geofencing, um präzise Ein- und Ausstempeldaten sicherzustellen.

KI-gestützter Workflow

Erzeugen Sie Backend-Grundgerüste und Integrationsanleitungen schnell mit einem strukturierten Prompt.

Bereit, Ihre Schichtplanungs-App zu starten?

Lassen Sie den Back4app KI-Agenten Ihr Schichtplanungs-Backend aufbauen und Benutzer, Schichten und Zeitpläne mit einem Prompt generieren.

Mit KI-Agent bauenProbieren Sie den API-Spielplatz aus

Kostenloser Start — 50 KI-Agenten-Prompts/Monat, keine Kreditkarte erforderlich

Technischer Stack

Alles in dieser Schichtplanungs-Backend-Vorlage enthalten.

Frontend
13+ Technologien
Backend
Back4app
Datenbank
MongoDB
Authentifizierung
Eingebaute Authentifizierung + Sitzungen
API
REST und GraphQL
Echtzeit
Live Queries

ER-Diagramm

Entity-Relationship-Modell für das Schichtplanungs-Backend-Schema.

Diagrammquelle anzeigen
Mermaid
erDiagram
    User ||--o{ Schedule : "user"
    User ||--o{ SwapRequest : "fromUser"
    User ||--o{ SwapRequest : "toUser"
    User ||--o{ ClockIn : "user"
    Shift ||--o{ Schedule : "shift"
    Shift ||--o{ SwapRequest : "shift"
    Shift ||--o{ ClockIn : "shift"

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

    Shift {
        String objectId PK
        String title
        Date startTime
        Date endTime
        GeoPoint location
        Date createdAt
        Date updatedAt
    }

    Schedule {
        String objectId PK
        Pointer user FK
        Pointer shift FK
        String status
        Date createdAt
        Date updatedAt
    }

    SwapRequest {
        String objectId PK
        Pointer fromUser FK
        Pointer toUser FK
        Pointer shift FK
        String status
        Date createdAt
        Date updatedAt
    }

    ClockIn {
        String objectId PK
        Pointer user FK
        Pointer shift FK
        Date clockInTime
        GeoPoint location
        Date createdAt
        Date updatedAt
    }

Integrationsfluss

Typischer Laufzeitfluss für Authentifizierung, Benutzerprofile, Schichten, Zeitpläne und Zeiterfassung.

Diagrammquelle anzeigen
Mermaid
sequenceDiagram
  participant User
  participant App as Shift Scheduling App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: View schedule
  App->>Back4app: GET /classes/Schedule
  Back4app-->>App: Schedule data

  User->>App: Request shift swap
  App->>Back4app: POST /classes/SwapRequest
  Back4app-->>App: SwapRequest objectId

  User->>App: Clock in
  App->>Back4app: POST /classes/ClockIn
  Back4app-->>App: ClockIn confirmation

Datenwörterbuch

Vollständige Feldreferenz für jede Klasse im Schichtplanungs-Schema.

FeldTypBeschreibungErforderlich
objectIdStringAuto-generated unique identifierAutomatisch
usernameStringUser login name
emailStringUser email address
passwordStringHashed password (write-only)
roleStringRole of the user (e.g., manager, employee)
createdAtDateAuto-generated creation timestampAutomatisch
updatedAtDateAuto-generated last-update timestampAutomatisch

7 Felder in User

Sicherheit und Berechtigungen

Wie die ACL- und CLP-Strategie Benutzer, Schichten und Zeitpläne sichert.

Vom Benutzer gesteuerte Zeitplansteuerungen

Nur der Benutzer kann seinen Zeitplan aktualisieren oder löschen; andere können Benutzerschichten nicht ändern.

Integrität von Schichten und Zeitplänen

Nur der Ersteller kann seine Schichten und Zeitpläne erstellen oder löschen. Verwenden Sie Cloud Code zur Validierung.

Gelesener Zugriff mit begrenztem Umfang

Beschränken Sie das Lesen von Schichten und Zeitplänen auf relevante Parteien (z. B. Benutzer sehen ihre eigenen Zeitpläne und öffentliche Schichten).

Schema (JSON)

Rohes JSON-Schema-Definition bereit zum Kopieren in Back4app oder zur Verwendung als Implementierungsreferenz.

JSON
{
  "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": "Shift",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "startTime": {
          "type": "Date",
          "required": true
        },
        "endTime": {
          "type": "Date",
          "required": true
        },
        "location": {
          "type": "GeoPoint",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Schedule",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "shift": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Shift"
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "SwapRequest",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "fromUser": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "toUser": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "shift": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Shift"
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "ClockIn",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "shift": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Shift"
        },
        "clockInTime": {
          "type": "Date",
          "required": true
        },
        "location": {
          "type": "GeoPoint",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Mit KI-Agent bauen

Verwenden Sie den Back4app AI-Agenten, um aus dieser Vorlage eine echte Schichtplanungs-App zu erstellen, einschließlich Frontend, Backend, Authentifizierung sowie Benutzer-, Schicht-, Planungs- und Zeiterfassungsabläufen.

Back4app AI-Agent
Bereit zum Erstellen
Erstellen Sie ein Backend für eine Schichtplanungs-App auf Back4app mit genau diesem Schema und Verhalten.

Schema:
1. Benutzer (verwenden Sie Back4app eingebaut): Benutzername, E-Mail, Passwort; objectId, createdAt, updatedAt (System).
2. Schicht: Benutzer (Pointer auf Benutzer, erforderlich), Startzeit (Datum, erforderlich), Endzeit (Datum, erforderlich), Standort (GeoPoint, optional); objectId, createdAt, updatedAt (System).
3. Plan: Benutzer (Pointer auf Benutzer, erforderlich), Schichten (Array von Pointern auf Schicht, erforderlich); objectId, createdAt, updatedAt (System).

Sicherheit:
- Nur der Benutzer kann seinen Plan aktualisieren/löschen. Nur der Ersteller kann seine Schichten erstellen/löschen. Verwenden Sie Cloud Code zur Validierung.

Auth:
- Registrierung, Anmeldung, Abmeldung.

Verhalten:
- Benutzer auflisten, Schichten erstellen, Schichten planen, ein- und ausstempeln und Schichtwechsel verwalten.

Lieferung:
- Back4app App mit Schema, ACLs, CLPs; Frontend für Benutzerprofile, Schichten, Pläne und Zeiterfassung.

Drücken Sie die Schaltfläche unten, um den Agenten mit diesem vorab ausgefüllten Vorlagen-Prompt zu öffnen.

Dies ist der Basis-Prompt ohne Technologiesuffix. Sie können den generierten Frontend-Stack anschließend anpassen.

In Minuten bereitstellen50 kostenlose Prompts / MonatKeine Kreditkarte erforderlich

API-Spielplatz

Probieren Sie REST- und GraphQL-Endpunkte gegen das Schichtplanungs-Schema aus. Antworten verwenden Mock-Daten und erfordern kein Back4app-Konto.

Spielplatz wird geladen…

Verwendet dasselbe Schema wie diese Vorlage.

Wählen Sie Ihre Technologie

Erweitern Sie jede Karte für Integrationsschritte, Zustandsmuster, Datenmodellbeispiele und Offline-Hinweise.

Flutter Schichtplanungs-Backend

React Schichtplanungs-Backend

React Native Schichtplanungs-Backend

Next.js Schichtplanungs-Backend

JavaScript Schichtplanungs-Backend

Android Schichtplanungs-Backend

iOS Schichtplanungs-Backend

Vue Schichtplanungs-Backend

Angular Schichtplanungs-Backend

GraphQL Schichtplanungs-Backend

REST API Schichtplanungs-Backend

PHP Schichtplanungs-Backend

.NET Schichtplanungs-Backend

Was Sie mit jeder Technologie erhalten

Jeder Stack verwendet dasselbe Schichtplanungs-Backend-Schema und API-Verträge.

Einheitliche Schichtdatensstruktur

Verwalten Sie einfach Schichten und Benutzer mit einem kohärenten Datenschema für Schichtplanung.

Echtzeit-Planungsaktualisierungen

Sofortige Benachrichtigungen bei Änderungen der Zeitpläne, die das Schichtplanung-Management verbessern.

Sichere Benutzerzugriffssteuerung

Schützen Sie sensible Schichtplanung-Informationen mit robusten Zugriffsberechtigungen.

REST/GraphQL-APIs für Schichtplanung

Integrieren Sie nahtlos mit jedem Frontend unter Verwendung flexibler APIs, die für Schichtplanung entwickelt wurden.

Automatisierte Schicht-Erinnerungen

Halten Sie Benutzer mit automatisierten Benachrichtigungen über bevorstehende Schichten in Schichtplanung informiert.

Erweiterbares Framework für Schichtplanung

Passen Sie Funktionen einfach an und erweitern Sie sie, um Ihren spezifischen Schichtplanung-Bedürfnissen gerecht zu werden.

Vergleich des Schichtplanungsrahmens

Vergleichen Sie die Einrichtgeschwindigkeit, den SDK-Stil und die KI-Unterstützung über alle unterstützten Technologien hinweg.

FrameworkEinrichtungszeitVorteil der SchichtplanungSDK-TypKI-Unterstützung
Flutter
Ungefähr 5 MinutenEinzelner Code für die Schichtplanung auf Mobilgeräten und im Web.Typed SDKVollständig
React
Unter 5 MinutenSchnelles Web-Dashboard für die Schichtplanung.Typed SDKVollständig
React Native
~3–7 MinutenPlattformübergreifende mobile App für die Schichtplanung.Typed SDKVollständig
Next.js
Schnelle (5 Minuten) EinrichtungServergerenderte Web-App für die Schichtplanung.Typed SDKVollständig
JavaScript
~3 MinutenLeichte Web-Integration für die Schichtplanung.Typed SDKVollständig
Android
Ungefähr 5 MinutenNative Android-App für die Schichtplanung.Typed SDKVollständig
iOS
Unter 5 MinutenNative iOS-App für die Schichtplanung.Typed SDKVollständig
Vue
~3–7 MinutenReact-Web-UI für die Schichtplanung.Typed SDKVollständig
Angular
Schnelle (5 Minuten) EinrichtungEnterprise-Web-App für die Schichtplanung.Typed SDKVollständig
GraphQL
Schnelle (2 Minuten) EinrichtungFlexibles GraphQL-API für die Schichtplanung.GraphQL APIVollständig
REST API
~2 MinutenREST API-Integration für die Schichtplanung.REST APIVollständig
PHP
Unter 5 MinutenServerseitiges PHP-Backend für die Schichtplanung.REST APIVollständig
.NET
~3–7 Minuten.NET-Backend für die Schichtplanung.Typed SDKVollständig

Die Einrichtungszeit spiegelt die erwartete Dauer vom Projektstart bis zur ersten geplanten Abfrage mit diesem Vorlagenschema wider.

Häufig gestellte Fragen

Häufige Fragen zum Aufbau eines Schichtplanungs-Backends mit dieser Vorlage.

Was ist ein Schichtplanungs-Backend?
Was beinhaltet die Schichtplanungs-Vorlage?
Warum Back4app für eine Planungs-App verwenden?
Wie führe ich Abfragen für Benutzer und Schichten mit Flutter aus?
Wie erstelle ich einen Zeitplan mit Next.js Server Actions?
Kann React Native Benutzer und Schichten offline zwischenspeichern?
Wie verhindere ich doppelte Schichten?
Was ist der beste Weg, um Benutzerprofile und Schichten auf Android anzuzeigen?
Wie funktioniert der Zeitstempelfluss von Anfang bis Ende?

Vertraut von Entwicklern weltweit

Schließen Sie sich Teams an, die schneller Planungsprodukte mit Back4app-Vorlagen versenden

G2 Users Love Us Badge

Bereit, Ihre Schichtplanungs-App zu erstellen?

Starten Sie Ihr Planungsprojekt in wenigen Minuten. Keine Kreditkarte erforderlich.

Technologie wählen