> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Application d'exemple : boîte de réception des notifications avec Event Streams

> Comment l'application d'exemple Clean Beans construit une boîte de réception des notifications dans l'application à partir d'Event Streams et synchronise les préférences e-mail avec les désabonnements.

Cette page fait partie de [Application d'exemple : une intégration OneSignal complète](https://documentation.onesignal.com/docs/fr/example-full-integration-overview.md), qui suit une application réelle de bout en bout. L'application s'appelle **Clean Beans**, un planning de ménage pour les logements partagés, construite avec Expo (React Native) et un backend Supabase.

Un push balayé disparaît. Clean Beans conserve un historique de sept jours dans l'application, avec un compteur de non-lus dans l'en-tête de chaque écran.

![La boîte de réception des notifications de Clean Beans](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-inbox.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=b5e476387dfc0b32a56d71201879c0d0)

La boîte de réception liste les notifications récentes.

L'application n'enregistre pas elle-même les notifications. Cela manquerait tout ce qui a été livré pendant que l'application était fermée. OneSignal informe le backend de chaque push via un **Event Stream**, et c'est le backend qui conserve l'historique.

**1. OneSignal envoie un événement pour chaque push**

Un Event Stream envoie une requête à une fonction backend lorsqu'un push est envoyé, puis à nouveau lorsqu'il est cliqué.

**2. La fonction enregistre ou met à jour une ligne**

Un événement d'envoi crée une entrée dans la boîte de réception. Un événement de clic la marque comme lue.

**3. L'application lit la table**

L'écran de la boîte de réception et le badge de l'en-tête interrogent les lignes de l'utilisateur.

## Configurer l'Event Stream \\

**Configuration du tableau de bord.** Dans **Data > Event Streams**, créez un stream avec :

* **URL :** l'adresse de votre fonction.
* **En-tête :** un secret partagé, par exemple `X-Webhook-Secret`.
* **Événements :** `message.push.sent` et `message.push.clicked`.
* **Corps :** un modèle Liquid qui met en forme la requête.

```json Event Stream body theme={null}
{
  "event_kind": "{{ event.kind }}",
  "event_id": "{{ event.id }}",
  "timestamp": {{ event.timestamp }},
  "external_id": "{{ event.external_id }}",
  "message_id": "{{ message.id }}",
  "title": "{{ message.title.en }}",
  "contents": "{{ message.contents.en }}",
  "data": { "type": "{{ message.data.type }}" }
}
```

> [!WARNING]
>
> Référencez chaque clé de `data` par son nom, comme ci-dessus. `{{ message.data }}` seul affiche l'objet entier sous forme de dict de style Python (`{'type': 'kudos'}`), qui n'est pas du JSON valide, et la fonction ci-dessous rejetterait la requête en analysant le corps. Le titre et le contenu sont lus avec `.en` pour la même raison. La boîte de réception n'a besoin que de `type`. Ajoutez une ligne pour chaque autre clé utilisée par votre propre webhook.
>
> Une valeur contenant un guillemet double casse également le JSON. Les push de kudos contiennent du texte saisi par un utilisateur, un message de kudos contenant un `"` produit donc un corps que la fonction ne peut pas analyser, et ce push n'arrive jamais dans la boîte de réception.

> [!NOTE]
>
> Ce stream envoie un événement pour chaque push livré à chaque appareil, et chaque événement est décompté du volume d'événements de messages de votre offre. Ne sélectionnez que les événements que vous utilisez.

## Recevoir les événements \\

La fonction vérifie le secret avant toute autre opération.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const secret = req.headers.get('X-Webhook-Secret') ?? '';
if (!INBOX_WEBHOOK_SECRET || secret !== INBOX_WEBHOOK_SECRET) {
  return new Response('Unauthorized', { status: 401 });
}
```

Un événement d'envoi devient une ligne de la boîte de réception. L'ID d'événement de OneSignal sert de clé unique, un événement livré deux fois ne crée donc pas deux lignes.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
if (event_kind === 'message.push.sent') {
  // ── Create inbox entry ──
  const notifType = (data?.type as string) || 'general';

  // inboxTitle and inboxBody are the title and contents with any Liquid
  // rendered. See "Render Liquid before you store it" below.

  const { error } = await supabase.from('inbox_messages').upsert(
    {
      user_id: profile.id,
      onesignal_event_id: event_id,
      onesignal_message_id: message_id,
      title: inboxTitle || 'Notification',
      body: inboxBody,
      type: notifType,
      data: data || {},
      read: false,
      created_at: payload.timestamp
        ? new Date(payload.timestamp * 1000).toISOString()
        : new Date().toISOString(),
    },
    { onConflict: 'onesignal_event_id' } // dedup
  );
```

Un événement de clic marque la ligne correspondante comme lue.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const { error, count } = await supabase
  .from('inbox_messages')
  .update({ read: true })
  .eq('onesignal_message_id', message_id)
  .eq('user_id', profile.id);
```

Le champ `data.type` qui route un push touché est enregistré avec chaque ligne, la boîte de réception peut donc afficher la bonne icône et ouvrir le bon écran.

## Interpréter le Liquid avant de l'enregistrer \\

Le stream transmet un message tel qu'il a été rédigé, avant que OneSignal ne le personnalise pour chaque destinataire. Un push envoyé par le backend a déjà son texte final. Un push de Journey, non. L'un des messages de Journey de Clean Beans a ce titre :

```text Journey push title theme={null}
{{ journey.first_event.properties.room_name }} cleaned ✅
```

Le téléphone affiche « Kitchen cleaned ✅ ». Le webhook reçoit la ligne ci-dessus, et la première version de la boîte de réception l'affichait telle quelle.

La fonction interprète désormais elle-même le titre et le corps avant de les enregistrer, avec un petit moteur de rendu qui gère la recherche de valeurs et le filtre `default`. Elle obtient les valeurs à deux endroits :

* **Les tags** sont lus dans la base de données. L'application définit chaque tag à partir d'une valeur qu'elle stocke, la fonction lit donc les mêmes valeurs. Transmettre `{{ user.tags.user_name }}` dans le corps du stream fonctionnerait aussi, mais un nom contenant un guillemet double rendrait ce corps invalide en JSON.
* **Les propriétés d'événement de Journey** ne sont pas disponibles dans le stream. La fonction les reconstitue à partir de la session de ménage qui a déclenché l'événement personnalisé.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
if (hasLiquid(inboxTitle) || hasLiquid(inboxBody)) {
  const context = await buildLiquidContext(supabase, payload);
  const renderedTitle = renderLiquid(inboxTitle, context);
  const renderedBody = renderLiquid(inboxBody, context);
  const unresolved = [...renderedTitle.unresolved, ...renderedBody.unresolved];

  if (unresolved.length > 0) {
    // Better no entry than one showing raw template tags
    console.warn(`Inbox: skipped ${message_id} for ${external_id}, unresolved Liquid: ${JSON.stringify(unresolved)}`);
    return jsonResponse({ skipped: true, reason: 'unresolved_liquid', unresolved });
  }

  inboxTitle = renderedTitle.text;
  inboxBody = renderedBody.text;
}
```

> [!WARNING]
>
> Si vous construisez une boîte de réception ou un journal à partir d'Event Streams, vérifiez à quoi ressemblent vos messages de Journey et de modèle à leur arrivée. Tout Liquid qu'ils contiennent reste du Liquid. Interprétez-le vous-même, comme ici, ou excluez ces messages.

## Afficher la boîte de réception \\

La sécurité au niveau des lignes garantit que chaque utilisateur ne peut lire que ses propres lignes, les requêtes de l'application n'ont donc pas besoin de filtrer par utilisateur.

```typescript app/inbox.tsx theme={null}
const { data, error } = await supabase
  .from('inbox_messages')
  .select('id, title, body, type, data, read, created_at')
  .order('created_at', { ascending: false })
  .limit(50);
```

```typescript src/components/InboxButton.tsx theme={null}
const fetchCount = async () => {
  const { count, error } = await supabase
    .from('inbox_messages')
    .select('id', { count: 'exact', head: true })
    .eq('read', false);

  if (!cancelled && !error && count !== null) {
    setUnreadCount(count);
  }
};
```

## Synchroniser les préférences e-mail \\

Le même stream résout un second problème. Lorsqu'une personne appuie sur **Unsubscribe** dans un e-mail, OneSignal cesse de lui envoyer des e-mails, mais l'interrupteur « Weekly Email Summary » de l'application resterait activé. L'écran des paramètres serait erroné, et le backend continuerait d'essayer d'envoyer.

Ajouter quatre événements e-mail au stream corrige ce problème. La fonction les traite tous de la même façon : OneSignal n'enverra plus d'e-mail à cette personne, la préférence de l'application est donc désactivée en conséquence.

```typescript supabase/functions/inbox-webhook/index.ts theme={null}
const EMAIL_STOP_EVENTS: Record<string, string> = {
  'message.email.unsubscribed': 'unsubscribed',
  'message.email.reported_as_spam': 'reported_as_spam',
  'message.email.bounced': 'bounced',
  'message.email.suppressed': 'suppressed',
};

// ...

const { error: prefErr } = await supabase
  .from('profiles')
  .update({ email_weekly_summary: false })
  .eq('id', profile.id);
```

Aucune modification du corps du stream n'est nécessaire, car les champs déjà utilisés par la boîte de réception (`event_kind`, `event_id`, `external_id`) suffisent.

> [!NOTE]
>
> Cela aligne l'application sur OneSignal, et non l'inverse. Si une personne réactive l'e-mail dans l'application, son abonnement OneSignal reste désabonné. Pour la réabonner, votre backend doit appeler l'API d'abonnement de OneSignal.

> [!TIP]
>
> Le même principe d'Event Stream permet de synchroniser vos propres systèmes avec tout ce que OneSignal sait : ouvertures d'e-mails, clics sur les messages in-app, livraisons de SMS, et plus encore.

> [card] [Event Streams](https://documentation.onesignal.com/docs/fr/event-streams.md)
>
> Configurer un stream et choisir les événements.

> [card] [Données Event Stream](https://documentation.onesignal.com/docs/fr/event-streams-data.md)
>
> Tous les champs disponibles dans le modèle de corps.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.