Backend de répit pour aidants

Modèle de backend d'application de répit pour aidants
Planifiez et gérez efficacement le répit temporaire pour les aidants familiaux

Q: Qu'est-ce qu'un backend de répit pour les soignants ?

Un backend de répit pour les soignants est un schéma et une API structurés BaaS pour des fonctionnalités telles que la planification, les attributions de soignants, la communication et l'enregistrement des audits.

Q: Que comprend le modèle de répit pour les soignants ?

Il comprend les classes CaregiverProfile, CareSchedule, CareAssignment, Communication et AuditLog, ainsi que des diagrammes ER et un environnement de test API.

Q: Pourquoi utiliser Back4app pour une application de répit pour les soignants ?

Back4app fournit une persistance gérée, une authentification, une génération d'API, des mises à jour en temps réel et du Cloud Code, permettant aux équipes de se concentrer sur les processus des soignants.

Q: Comment récupérer les plannings d'un soignant en une seule requête ?

Utilisez GraphQL avec une sélection imbriquée ou une requête REST incluant l'expansion des pointeurs pour récupérer les attributions ainsi que le profil du soignant.

Q: Comment marquer une communication comme lue ?

Mettez à jour le statut de l'enregistrement de la communication et enregistrez éventuellement l'action dans l'AuditLog.

Un backend de répit pour aidants prêt pour la production sur Back4app avec une planification sécurisée, gestion de soins temporaires et communication avec les aidants. Comprend un diagramme ER, un dictionnaire de données, un schéma JSON, un terrain de jeu API et un prompt Agent IA pour un démarrage rapide.

Construire avec l'agent IA Choisissez votre technologie

Points clés

Expédiez un backend orienté vers les aidants avec des contrôles d'accès sécurisés, des transitions de soins, des journaux de communication et des pistes de vérification, afin que votre équipe puisse se concentrer sur le développement d'applications conviviales.

Modèle de données centré sur les aidants — Conservez les profils des aidants, les horaires de soins, les affectations et les communications gérés séparément mais liés pour une supervision et une autorisation claires.
Communication sécurisée — Facilitez les messages en fil sécurisé entre les aidants et les familles avec des accusés de réception clairs et des contrôles de conservation.
Planification complète — Stockez les horaires de soins avec une gestion précise des dates et des heures pour garantir que les aidants et les familles soient toujours informés.
Pistes d'audit — Capturez tous les changements et communications à travers un AuditLog pour la conformité et la révision.
Développement et déploiement rapides — Utilisez le schéma pré-construit et l'invite AI Agent pour optimiser vos délais de projet.

Qu'est-ce que le modèle de backend de l'application de répit pour les aidants?

Back4app est un backend en tant que service (BaaS) pour une livraison rapide. Le modèle de backend de l'application de répit pour les aidants est un schéma pré-construit pour les profils d'aidants, les emplois du temps de soins, les attributions, la messagerie sécurisée et les journaux d'audit. Connectez votre frontend préféré (React, Flutter, Next.js, et plus) et expédiez plus rapidement.

Meilleur pour :

Applications de soutien aux aidantsGestion des soins temporairesSystèmes de planificationCommunication sécurisée pour les soignantsFamilles nécessitant un soulagement des soinsÉquipes développant des applications pour les besoins des soignants

Aperçu

Les applications de répit des soignants nécessitent une gestion efficace des données, un audit des changements et une planification fiable des soins pour soutenir les familles dans le besoin.

Ce modèle définit CaregiverProfile, CareSchedule, CareAssignment, Communication et AuditLog avec des règles de propriété et basées sur les rôles afin que les équipes puissent mettre en œuvre des applications de répit pour soignants rapidement et en toute sécurité.

Caractéristiques principales du répit des aidants

Chaque carte technologique dans ce hub utilise le même schéma de backend de répit des soignants avec CaregiverProfile, CareSchedule, CareAssignment, Communication et AuditLog.

Profil de l'aidant et authentification

Le ProfilDeLaidant stocke l'identité, les coordonnées et les préférences.

Planification des soins flexible

Le HoraireDeSoins conserve le temps Blocks pour les soins temporaires, reliant les aidants assignés et les patients.

Gestion des attributions de soins

L'AttributionDeSoins stocke l'état de l'aidant, enregistre le lien des horaires et surveille les attributions.

Communication sécurisée des soignants

La communication permet des messages en fil entre les soignants et les familles, assurant des mises à jour en temps utile.

Journaux d'audit centralisés

Le journal d'audit capture l'identité de l'acteur, le type d'action, le contexte de l'entité et les métadonnées de la charge utile pour la conformité.

Pourquoi construire le backend de votre application de répit pour aidants avec Back4app ?

Back4app gère les fondamentaux du backend : sécurité, persistance, API et temps réel, afin que vous puissiez vous concentrer sur l'expérience des aidants, la planification des flux de travail et la communication efficace.

•Gestion sécurisée des données: Des modèles d'authentification et de contrôle d'accès (ACL/CLP) intégrés vous permettent de contrôler exactement quels utilisateurs peuvent accéder aux plannings de soins et à la communication.
•Journalisation complète: AuditLog capture qui a consulté ou modifié des dossiers sensibles pour garantir la conformité et les capacités de révision.
•Capacités de messagerie: Des messages et des notifications en fil de discussion rendent la communication avec les aidants fluide et opportune.

Déployez rapidement un backend sécurisé pour le répit des aidants et itérez sur les flux de travail de planification au lieu de gérer le backend.

Avantages principaux

Un backend de répit des soignants qui met l'accent sur l'efficacité, la sécurité et la rapidité de livraison.

Processus des soignants accélérés

Planification des expéditions, gestion des affectations et communication plus rapide en réutilisant un backend validé.

Mécanismes d'audit robustes

Assurez-vous que toutes les actions sont auditées et traçables pour la conformité.

Permissions granulaires

Protégez les informations sensibles avec des contrôles ACL/CLP et de rôle.

Messagerie intégrée

La messagerie en fil avec des pièces jointes sécurisées améliore la collaboration entre les soignants et les familles.

Architecture conforme

AuditLog centralisé prend en charge les examens, l'enquête sur les incidents et le reporting de conformité.

Bootstrap assisté par l'IA

Démarrez le développement avec une invite d'agent IA soigneusement sélectionnée qui structure le schéma, les ACL et le code d'intégration.

Prêt à créer une application de répit pour les aidants sécurisée ?

Laissez l'agent IA Back4app structurer votre backend de répit pour aidants et générer des profils d'aidants, des horaires de soins, des missions, des communications et des journaux d'audit à partir d'une seule invite.

Construire avec l'agent IA Essayez l'API Playground

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

Stack technique

Tout est inclus dans ce modèle de backend de répit pour aidants.

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

Modèle de relation d'entité pour le schéma backend de Caregiver Respite.

common.erDiagramPlaceholder

Voir la source du diagramme

Mermaid

erDiagram
    CaregiverProfile ||--o{ RespiteCareSession : "provides"
    CaregiverProfile ||--o{ CaregiverMessage : "sends/receives"
    CaregiverProfile ||--o{ Appointment : "assigned to"
    RespiteCareSession ||--o{ Appointment : "is associated with"
    _User ||--o{ CaregiverMessage : "interacts with"

    CaregiverProfile {
        String objectId PK
        Pointer user FK
        String careRecipientName
        Number careRecipientAge
        String contactInfo
        Boolean isActive
        Date createdAt
        Date updatedAt
    }

    RespiteCareSession {
        String objectId PK
        Pointer caregiver FK
        Date sessionStart
        Date sessionEnd
        String location
        String status
        Date createdAt
        Date updatedAt
    }

    CaregiverMessage {
        String objectId PK
        String conversationId
        Pointer from FK
        Pointer to FK
        String body
        Boolean isRead
        Date sentAt
        Date createdAt
        Date updatedAt
    }

    Appointment {
        String objectId PK
        Pointer caregiver FK
        Pointer session FK
        String reason
        String status
        Date createdAt
        Date updatedAt
    }

    AuditLog {
        String objectId PK
        Pointer actor FK
        String entityType
        String entityId
        String action
        String summary
        Object metadata
        Date createdAt
        Date updatedAt
    }

Flux d'intégration

Flux d'exécution typique pour la connexion des aidants, la planification, la gestion des attributions et la communication.

common.erDiagramPlaceholder

Voir la source du diagramme

Mermaid

sequenceDiagram
  participant Caregiver
  participant App as Caregiver Respite App
  participant RespiteProvider
  participant Back4app as Back4app Cloud

  Caregiver->>App: Sign in with email or SSO
  App->>Back4app: POST /login (credentials/SSO token)
  Back4app-->>App: Return Session Token + Caregiver context

  Caregiver->>App: Open Dashboard (profile & active sessions)
  App->>Back4app: GET /classes/CaregiverProfile?where={"user":Pointer("_User", "u123")}
  Back4app-->>App: CaregiverProfile object
  App->>Back4app: GET /classes/RespiteCareSession?where={"caregiver":Pointer("CaregiverProfile","c123")}&order=-sessionStart
  Back4app-->>App: List of RespiteCareSession (latest first)

  Caregiver->>App: View upcoming appointments
  App->>Back4app: GET /classes/Appointment?where={"caregiver":Pointer("CaregiverProfile","c123"),"status":"scheduled"}
  Back4app-->>App: Appointment object

  Caregiver->>App: Send a message to a respite provider
  App->>Back4app: POST /classes/CaregiverMessage (conversationId, body, to: Pointer(_User, providerId))
  Back4app-->>App: CaregiverMessage objectId

  Back4app-->>App: LiveQuery -> new message or session updates
  App-->>Caregiver: Real-time notification (new message / session updated)

  RespiteProvider->>Back4app: Update RespiteCareSession (finalize)
  Back4app-->>App: LiveQuery event -> App fetches updated RespiteCareSession
  App-->>Caregiver: Alert: "New session update available"

Dictionnaire de données

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

Champ	Type	Description	Requis
objectId	String	Auto-generated unique identifier	Automatique
user	Pointer<_User>	Linked Back4app user account
careRecipientName	String	Name of the individual being cared for
careRecipientAge	Number	Age of the individual being cared for	—
contactInfo	String	Contact information for the caregiver	—
isActive	Boolean	Active profile flag
createdAt	Date	Auto-generated creation timestamp	Automatique
updatedAt	Date	Auto-generated last-update timestamp	Automatique

8 champs dans CaregiverProfile

Sécurité et autorisations

Comment les stratégies ACL, CLP et de cryptage sécurisent les données, les horaires et la communication des soignants.

Accès et propriété basés sur les rôles

Appliquer des ACL afin que les soignants puissent voir leurs propres horaires et messages assignés ; les CLP empêchent les opérations non autorisées.

Charges utiles et pièces jointes chiffrées

Stocker des blobs sensibles (pièces jointes de message) derrière des URL signées et utiliser le cryptage au niveau du stockage pour une protection au repos.

Historique d’audit en mode ajout uniquement

Écrire des entrées AuditLog depuis le Cloud Code côté serveur pour s'assurer que les entrées historiques ne peuvent pas être falsifiées.

Schéma (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

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": "CaregiverProfile",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "careRecipientName": {
          "type": "String",
          "required": true
        },
        "careRecipientAge": {
          "type": "Number",
          "required": false
        },
        "contactInfo": {
          "type": "String",
          "required": false
        },
        "isActive": {
          "type": "Boolean",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "RespiteCareSession",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caregiver": {
          "type": "Pointer",
          "required": true,
          "targetClass": "CaregiverProfile"
        },
        "sessionStart": {
          "type": "Date",
          "required": true
        },
        "sessionEnd": {
          "type": "Date",
          "required": true
        },
        "location": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "CaregiverMessage",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "conversationId": {
          "type": "String",
          "required": true
        },
        "from": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "to": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "body": {
          "type": "String",
          "required": true
        },
        "isRead": {
          "type": "Boolean",
          "required": true
        },
        "sentAt": {
          "type": "Date",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Appointment",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "caregiver": {
          "type": "Pointer",
          "required": true,
          "targetClass": "CaregiverProfile"
        },
        "session": {
          "type": "Pointer",
          "required": true,
          "targetClass": "RespiteCareSession"
        },
        "reason": {
          "type": "String",
          "required": false
        },
        "status": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AuditLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "actor": {
          "type": "Pointer",
          "required": true,
          "targetClass": "_User"
        },
        "entityType": {
          "type": "String",
          "required": true
        },
        "entityId": {
          "type": "String",
          "required": true
        },
        "action": {
          "type": "String",
          "required": true
        },
        "summary": {
          "type": "String",
          "required": true
        },
        "metadata": {
          "type": "Object",
          "required": false
        },
        "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 application de répit pour les aidants à partir de ce modèle, y compris le schéma backend, les ACL et l'intégration frontend de démarrage.

Agent IA Back4app

Prêt à construire

Créez un backend de répit pour les aidants sur Back4app avec ce schéma et ce comportement exacts.

Schéma :
1. ProfilAidant : utilisateur (Pointeur vers Utilisateur, requis), nomComplet (Chaîne, requis), contact (Objet), typeAidant (Chaîne) ; objectId, createdAt, updatedAt.
2. HoraireDeSoins : aidant (Pointeur vers ProfilAidant, requis), patient (Pointeur vers ProfilPatient, requis), heureDébut (Date, requis), heureFin (Date, requis) ; objectId, createdAt, updatedAt.
3. AttributionDeSoins : aidant (Pointeur vers ProfilAidant, requis), horaire (Pointeur vers HoraireDeSoins, requis), statut (Chaîne : actif, terminé) ; objectId, createdAt, updatedAt.
4. Communication : expéditeur (Pointeur vers Utilisateur, requis), destinataire (Pointeur vers Utilisateur, requis), corps (Chaîne), piècesJointes (Tableau de Fichier), horodatage (Date) ; objectId, createdAt, updatedAt.
5. JournalD'Audit : acteur (Pointeur vers Utilisateur, requis), action (Chaîne, requis), typeEntité (Chaîne, requis), idEntité (Chaîne, requis), chargeUtile (Objet, facultatif), createdAt (Date) ; objectId, createdAt, updatedAt.

Sécurité :
- Faites respecter les ACLs afin que les aidants ne puissent lire que leurs enregistrements de HoraireDeSoins et de Communication. Sécurisez les transitions avec le Cloud Code qui journalise également les entrées de JournalD'Audit.

Auth :
- Prise en charge de l'inscription des aidants ; attribution de rôles ; connexion sécurisée et gestion des sessions.

Comportement :
- L'aidant se connecte, récupère les services de soins programmés, attribue des tâches et communique avec les familles ; le système enregistre les actions via le JournalD'Audit.

Livraison :
- Application Back4app avec schéma, ACLs, hooks Cloud Code pour la planification, la communication et l'enregistrement, et intégration de démarrage pour les services d'aidant.

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

Ceci est l'invite de base sans suffixe technologique. Vous pouvez adapter la pile frontend générée par la suite.

Déployer en quelques minutes50 invites gratuites / moisAucune carte de crédit requise

API Playground

Essayez les endpoints REST et GraphQL contre le schéma de Répit pour les aidants. Les réponses utilisent des données de simulation et ne nécessitent pas de compte Back4app.

common.loadingPlayground

Utilise le même schéma que ce modèle.

Choisissez votre technologie

Développez chaque carte pour les étapes d'intégration, les modèles d'état, des exemples de modèles de données et des notes hors ligne.

Ce que vous obtenez avec chaque technologie

Chaque pile utilise le même schéma de backend et contrats API de Caregiver Respite.

Structure de données unifiée des aidants

Gérez les profils et les horaires des aidants dans un format unique et cohérent pour répit des aidants.

Messagerie sécurisée pour répit des aidants

Facilitez la communication confidentielle entre les aidants et les familles avec un chiffrement de bout en bout.

Gestion flexible des tâches de soins

Assignez et suivez facilement les tâches de soins adaptées aux besoins individuels dans répit des aidants.

Journaux d'audit complets

Conservez des dossiers détaillés de toutes les interactions et modifications pour la conformité dans répit des aidants.

APIs REST/GraphQL pour répit des aidants

Accédez et manipulez vos données en toute transparence avec des API robustes conçues pour répit des aidants.

Cadre extensible pour répit des aidants

Personnalisez et développez votre application facilement pour répondre aux besoins évolutifs dans répit des aidants.

Comparaison du cadre de répit pour les aidants

Comparez la vitesse de configuration, le style SDK et le support AI à travers toutes les technologies supportées.

Framework	Temps de configuration	Avantage de répit pour les aidants	Type de SDK	Support AI
Flutter	Configuration rapide (5 min)	Codebase unique pour le répit des aidants sur mobile et web.	Typed SDK	Complet
React	~5 min	Tableau de bord web rapide pour le répit des aidants.	Typed SDK	Complet
React Natif	Environ 5 min	Application mobile multiplateforme pour le répit des aidants.	Typed SDK	Complet
Next.js	Moins de 5 minutes	Application web rendue côté serveur pour le répit des aidants.	Typed SDK	Complet
JavaScript	Moins de 5 min	Intégration web légère pour le répit des aidants.	Typed SDK	Complet
Android	Configuration rapide (5 min)	Application Android native pour le répit des aidants.	Typed SDK	Complet
iOS	~5 min	Application iOS native pour le répit des aidants.	Typed SDK	Complet
Vue	Environ 5 min	Interface utilisateur web Reactive pour le répit des aidants.	Typed SDK	Complet
Angular	Moins de 5 minutes	Application web d'entreprise pour le répit des aidants.	Typed SDK	Complet
GraphQL	~2 min	API GraphQL flexible pour le répit des aidants.	GraphQL API	Complet
REST API	Moins de 2 min	Intégration REST API pour le répit des aidants.	REST API	Complet
PHP	~3–5 min	Backend PHP côté serveur pour le répit des aidants.	REST API	Complet
.NET	Environ 5 min	Backend .NET pour le répit des aidants.	Typed SDK	Complet

Le temps de configuration reflète la durée prévue entre le lancement du projet et la première connexion du soignant ainsi que la requête de plan de soin en utilisant ce schéma de modèle.

Questions Fréquemment Posées

Questions courantes sur la création d'un backend de répit pour les aidants avec ce modèle.

Qu'est-ce qu'un backend de répit pour les soignants ?

Que comprend le modèle de répit pour les soignants ?

Pourquoi utiliser Back4app pour une application de répit pour les soignants ?

Comment récupérer les plannings d'un soignant en une seule requête ?

Comment marquer une communication comme lue ?

Approuvé par des développeurs du monde entier

Rejoignez des équipes expédiant des solutions de répit pour soignants plus rapidement avec les modèles Back4app

Prêt à créer votre application de répit pour soignants ?

Commencez votre projet de répit pour soignants en quelques minutes. Aucune carte de crédit requise.

Choisissez la technologie

Modèle de backend d'application de répit pour aidantsPlanifiez et gérez efficacement le répit temporaire pour les aidants familiaux