> ## 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.

# Aplicativo de exemplo: caixa de entrada de notificações com Event Streams

> Como o aplicativo de exemplo Clean Beans cria uma caixa de entrada de notificações no aplicativo a partir de Event Streams e mantém as preferências de email alinhadas com os cancelamentos.

Esta página faz parte de [Aplicativo de exemplo: uma integração completa do OneSignal](https://documentation.onesignal.com/docs/pt-BR/example-full-integration-overview.md), que acompanha um aplicativo real do início ao fim. O aplicativo é o **Clean Beans**, uma escala de limpeza para casas compartilhadas, construído com Expo (React Native) e um backend Supabase.

Um push descartado desaparece. O Clean Beans mantém um histórico de sete dias dentro do aplicativo, com uma contagem de não lidas no cabeçalho de cada tela.

![A caixa de entrada de notificações do Clean Beans](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-inbox.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=b5e476387dfc0b32a56d71201879c0d0)

A caixa de entrada lista as notificações recentes.

O aplicativo não registra as notificações por conta própria. Isso deixaria de fora tudo o que foi entregue enquanto o aplicativo estava fechado. O OneSignal informa o backend sobre cada push por meio de um **Event Stream**, e o backend mantém o histórico.

**1. O OneSignal envia um evento para cada push**

Um Event Stream faz um POST para uma função de backend quando um push é enviado e novamente quando é clicado.

**2. A função armazena ou atualiza uma linha**

Um evento de envio cria uma entrada na caixa de entrada. Um evento de clique a marca como lida.

**3. O aplicativo lê a tabela**

A tela da caixa de entrada e o badge do cabeçalho consultam as linhas do próprio usuário.

## Configurar o Event Stream \\

**Configuração do painel.** Em **Data > Event Streams**, crie um stream com:

* **URL:** o endereço da sua função.
* **Cabeçalho:** um segredo compartilhado, por exemplo `X-Webhook-Secret`.
* **Eventos:** `message.push.sent` e `message.push.clicked`.
* **Corpo:** um template Liquid que dá forma à solicitação.

```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]
>
> Referencie cada chave de `data` pelo nome, como acima. `{{ message.data }}` sozinho renderiza o objeto inteiro como um dict no estilo Python (`{'type': 'kudos'}`), que não é JSON válido, e a função abaixo rejeitaria a solicitação ao analisar o corpo. O título e o conteúdo são lidos com `.en` pelo mesmo motivo. A caixa de entrada só precisa de `type`. Adicione uma linha para cada outra chave que o seu próprio webhook usar.
>
> Um valor que contém aspas duplas também quebra o JSON. Os pushes de kudos carregam um texto digitado pelo usuário, então uma mensagem de kudos com `"` gera um corpo que a função não consegue analisar, e esse push nunca chega à caixa de entrada.

> [!NOTE]
>
> Este stream envia um evento para cada push entregue a cada dispositivo, e cada evento conta para o volume de eventos de mensagens do seu plano. Selecione apenas os eventos que você usa.

## Receber os eventos \\

A função verifica o segredo antes de fazer qualquer outra coisa.

```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 });
}
```

Um evento de envio vira uma linha da caixa de entrada. O ID de evento do OneSignal é a chave única, então um evento entregue duas vezes não cria duas linhas.

```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
  );
```

Um evento de clique marca a linha correspondente como lida.

```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);
```

O campo `data.type` que roteia um push tocado é armazenado com cada linha, para que a caixa de entrada possa mostrar o ícone certo e abrir a tela certa.

## Renderizar o Liquid antes de armazenar \\

O stream informa a mensagem como foi escrita, antes de o OneSignal personalizá-la para cada destinatário. Um push enviado pelo backend já tem o texto final. Um push de Journey, não. Uma das mensagens de Journey do Clean Beans tem este título:

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

O telefone mostra "Kitchen cleaned ✅". O webhook recebe a linha acima, e a primeira versão da caixa de entrada a exibia exatamente assim.

Agora a função renderiza o título e o corpo por conta própria antes de salvá-los, com um pequeno renderizador que trata consultas de valores e o filtro `default`. Ela obtém os valores de dois lugares:

* **As tags** são lidas do banco de dados. O aplicativo define cada tag a partir de um valor que armazena, então a função lê os mesmos valores. Passar `{{ user.tags.user_name }}` no corpo do stream também funcionaria, mas um nome com aspas duplas tornaria esse corpo um JSON inválido.
* **As propriedades de eventos da Journey** não estão disponíveis no stream. A função as reconstrói a partir da sessão de limpeza que disparou o evento personalizado.

```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]
>
> Se você criar uma caixa de entrada ou um log a partir de Event Streams, verifique como suas mensagens de Journey e de template chegam. Todo Liquid nelas continua sendo Liquid. Renderize-o você mesmo, como aqui, ou deixe essas mensagens de fora.

## Mostrar a caixa de entrada \\

A segurança em nível de linha faz com que cada usuário só possa ler as próprias linhas, então as consultas do aplicativo não precisam filtrar por usuário.

```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);
  }
};
```

## Manter as preferências de email alinhadas \\

O mesmo stream resolve um segundo problema. Quando alguém toca em **Unsubscribe** em um email, o OneSignal para de enviar emails para essa pessoa, mas o interruptor "Weekly Email Summary" do próprio aplicativo continuaria ativado. A tela de configurações estaria errada, e o backend continuaria tentando enviar.

Adicionar quatro eventos de email ao stream resolve isso. A função trata todos da mesma forma: o OneSignal não enviará mais emails para essa pessoa, então a preferência do aplicativo é desativada para corresponder.

```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);
```

Não é preciso mudar o corpo do stream, porque os campos que a caixa de entrada já usa (`event_kind`, `event_id`, `external_id`) são suficientes.

> [!NOTE]
>
> Isso mantém o aplicativo alinhado com o OneSignal, e não o contrário. Se alguém reativar o email no aplicativo, a Subscription no OneSignal continua cancelada. Para inscrever a pessoa novamente, seu backend precisa chamar a API de Subscriptions do OneSignal.

> [!TIP]
>
> O mesmo padrão de Event Stream pode manter seus próprios sistemas alinhados com qualquer coisa que o OneSignal saiba: aberturas de email, cliques em mensagens in-app, entregas de SMS e mais.

> [card] [Event Streams](https://documentation.onesignal.com/docs/pt-BR/event-streams.md)
>
> Configure um stream e escolha os eventos.

> [card] [Dados do Event Stream](https://documentation.onesignal.com/docs/pt-BR/event-streams-data.md)
>
> Todos os campos disponíveis no template do corpo.


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