davide/CRAPP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fa arrivare le push ad app chiusa e rende diagnosticabile quando non arrivano.

Browse Source 
Il testo della notifica viaggia ora cifrato dentro la push (aes128gcm, RFC
8188/8291) invece di essere recuperato dal service worker con una fetch al
risveglio. Era quella fetch a non chiudersi in tempo: ad app chiusa il browser
tiene vivo il worker pochi secondi, showNotification non veniva mai chiamata e
non compariva niente, mentre ad app aperta con la rete calda sembrava tutto a
posto. La POST porta anche Urgency: high, che chiede la consegna immediata
invece di far accumulare i messaggi fino al risveglio del dispositivo.

Cadono i pezzi che esistevano solo per rimediare al payload vuoto: la route
push-messaggio, la coda promemoria_push con la sua scadenza a 12 ore,
messaggioPalloniOggi() e il timeout nel worker. Tutti e tre i mittenti avevano
gia il testo pronto prima di inviare.

Il worker si aggiorna da solo all'avvio e a ogni ritorno in primo piano
(mantieniWorkerPushAggiornato): nella webapp installata quello vecchio puo
sopravvivere a lungo, e senza questo un dispositivo resterebbe fermo alla
versione che va a cercare il testo in rete.

Profilo -> Opzioni ha "Mandami una notifica di prova", visibile solo a notifiche
attive: manda una push a questo dispositivo e riporta stato HTTP, corpo della
risposta e se l'endpoint risulta davvero in push_subscriptions. Senza, "non
arriva" era cieco: ogni prova richiedeva un admin, un evento nello stato giusto
e una seconda persona, e la risposta del servizio push veniva buttata via.
inviaPush torna { stato, corpo } e logga il corpo sui rifiuti.

Dalle prove sul campo: a parita di server, iPhone installato da Home riceve ad
app chiusa. Su Android installato come webapp resta da verificare: il WebAPK e
un'app Android a se, con permesso notifiche (Android 13+) e voce batteria
distinti da quelli di Chrome. Annotato nei limiti noti.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
davide
2026-09-06 14:24:07 +02:00
co-authored by Claude Opus 5
parent 2b8ba340a6
commit d8f334007b
26 changed files with 782 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/palloni-core.ts
+1 -36
View File
@@ -107,47 +107,12 @@ export function destinatariPromemoriaPalloni(
return [...destinatari];
}
/** Testo del push per un giocatore: priorità a "riporta oggi", poi "tocca a te", poi generico. */
export function messaggioPalloniOggi(
turni: Record<string, string>,
eventi: Evento[],
oggi: string,
mioId: string,
nome: string,
): { title: string; body: string } {
for (const evento of eventiDelGiorno(eventi, oggi)) {
const prima = eventoPrecedente(eventi, evento.id);
if (prima && turni[prima.id] === mioId) {
return {
title: "Porta i palloni oggi",
body: `${evento.titolo} · ${evento.ora}. I palloni li hai tu dalla volta scorsa.`,
};
}
if (turni[evento.id] === mioId) {
const dopo = eventoSuccessivo(eventi, evento.id);
return {
title: "Tocca a te prendere i palloni",
body: dopo
? `A fine ${evento.titolo} porta a casa i palloni e riportali il ${formatData(dopo.data)}.`
: `A fine ${evento.titolo} porta a casa i palloni.`,
};
}
}
return {
title: "CrAPP · Turno palloni",
body: nome ? `${nome}, controlla il turno palloni nel calendario.` : "Controlla il calendario.",
};
}
/**
* Avvisi da mandare per un evento preciso, con il testo già pronto (DD-025).
*
* Diverso da `destinatariPromemoriaPalloni`, che guarda la giornata di oggi: qui l'admin
* sceglie l'evento dalla sua pagina, quindi il messaggio nomina quell'evento e non "oggi".
* Il testo viaggia in coda su `promemoria_push` perché la push parte vuota e il service
* worker chiede a `push-messaggio` cosa mostrare — che da solo saprebbe raccontare solo
* la giornata corrente.
* Il testo viaggia cifrato dentro la push, quindi il service worker lo mostra senza rete.
*/
export function avvisiPalloniEvento(
turni: Record<string, string>,
src/lib/push-client.ts
+50
View File
@@ -21,6 +21,30 @@ export function pushSupportato() {
);
}
/** Aggiorna il worker già installato anche nelle sessioni lunghe della webapp. */
export function mantieniWorkerPushAggiornato(): () => void {
if (!pushSupportato()) return () => {};
let inCorso = false;
const aggiorna = async () => {
if (document.visibilityState !== "visible" || inCorso) return;
inCorso = true;
try {
const reg = await navigator.serviceWorker.getRegistration("/push-sw.js");
// Non registrare né iscrivere chi non ha mai attivato le notifiche.
await reg?.update();
} catch {
// Offline: il worker attivo resta valido. Si riprova al prossimo ritorno nell'app.
} finally {
inCorso = false;
}
};
void aggiorna();
document.addEventListener("visibilitychange", aggiorna);
return () => document.removeEventListener("visibilitychange", aggiorna);
}
export async function statoNotifiche(): Promise<boolean> {
if (!pushSupportato()) return false;
const reg = await navigator.serviceWorker.getRegistration("/push-sw.js");
@@ -56,6 +80,32 @@ export async function attivaNotifiche(giocatoreId: string): Promise<void> {
if (!res.ok) throw new Error("Salvataggio iscrizione non riuscito");
}
/**
* Manda una push di prova a questo dispositivo e racconta com'è andata.
*
* Esiste perché "non arriva" è un sintomo cieco: senza, ogni prova richiede un admin, un
* evento nello stato giusto e una seconda persona. L'invio è immediato: per verificare
* l'arrivo ad app chiusa serve invece un invio da un altro dispositivo.
*/
export async function notificaDiProva(): Promise<{
nelDatabase: boolean;
stato: number;
corpo: string;
}> {
if (!pushSupportato()) throw new Error("Notifiche non supportate su questo dispositivo");
const reg = await navigator.serviceWorker.getRegistration("/push-sw.js");
const sub = await reg?.pushManager.getSubscription();
if (!sub) throw new Error("Notifiche non attive su questo dispositivo");
const res = await fetch("/api/public/push-prova", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ endpoint: sub.endpoint }),
});
if (!res.ok) throw new Error("Prova non riuscita");
return (await res.json()) as { nelDatabase: boolean; stato: number; corpo: string };
}
export async function disattivaNotifiche(): Promise<void> {
if (!pushSupportato()) return;
const reg = await navigator.serviceWorker.getRegistration("/push-sw.js");
src/lib/webpush.server.ts
+112 -21
View File
@@ -1,4 +1,4 @@
/** Invio di notifiche web push (senza payload) firmate con VAPID, compatibile con il runtime edge. */
/** Invio di notifiche web push con payload cifrato (RFC 8291), firmate con VAPID, compatibile con il runtime edge. */
function base64UrlDecode(value: string): Uint8Array {
const padding = "=".repeat((4 - (value.length % 4)) % 4);
@@ -17,6 +17,16 @@ function base64UrlEncode(bytes: Uint8Array): string {
return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function concat(...parti: Uint8Array[]): Uint8Array {
const out = new Uint8Array(parti.reduce((n, p) => n + p.length, 0));
let offset = 0;
for (const parte of parti) {
out.set(parte, offset);
offset += parte.length;
}
return out;
}
function encodeJson(value: unknown): string {
return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value)));
}
@@ -60,40 +70,121 @@ async function creaVapidJwt(
return `${header}.${payload}.${base64UrlEncode(new Uint8Array(firma))}`;
}
/**
* Per quante ore un messaggio in coda su `promemoria_push` resta un promemoria.
*
* La coda si svuota solo quando il dispositivo legge il messaggio, e se la push non arriva
* mai (registrazione scaduta: i server push accettano con 2xx e poi buttano via) la riga
* resta lì. Senza una scadenza, la notifica successiva — di qualunque tipo — mostrerebbe
* un sollecito di giorni prima, per un evento ormai passato.
*/
export const ORE_VALIDITA_PROMEMORIA = 12;
/** Un dispositivo iscritto: endpoint del servizio push e chiavi con cui cifrare per lui. */
export type IscrizionePush = { endpoint: string; p256dh: string; auth: string };
/** Un promemoria accodato è ancora attuale? */
export function promemoriaAncoraValido(creatoIl: string, adesso: Date = new Date()): boolean {
const creato = Date.parse(creatoIl);
if (Number.isNaN(creato)) return false;
return adesso.getTime() - creato < ORE_VALIDITA_PROMEMORIA * 60 * 60 * 1000;
async function hkdf(salt: Uint8Array, ikm: Uint8Array, info: Uint8Array, byte: number) {
const chiave = await crypto.subtle.importKey("raw", ikm as BufferSource, "HKDF", false, [
"deriveBits",
]);
const bits = await crypto.subtle.deriveBits(
{ name: "HKDF", hash: "SHA-256", salt: salt as BufferSource, info: info as BufferSource },
chiave,
byte * 8,
);
return new Uint8Array(bits);
}
/** Invia una notifica "vuota": il service worker recupera poi il testo aggiornato. */
export async function inviaPush(endpoint: string): Promise<number> {
function etichetta(testo: string): Uint8Array {
return concat(new TextEncoder().encode(testo), new Uint8Array([0]));
}
/**
* Cifra il testo della notifica nel corpo della push, in formato `aes128gcm`.
*
* Esportata solo per i test: il payload viaggia dentro la push proprio perché il service
* worker non abbia bisogno della rete per sapere cosa mostrare — a dispositivo dormiente
* il browser lo sveglia per pochi secondi e una fetch di troppo lo fa morire prima di
* `showNotification`, cioè niente notifica ad app chiusa.
*/
export async function cifraPayload(
iscrizione: IscrizionePush,
testoInChiaro: string,
): Promise<Uint8Array> {
const uaPublic = base64UrlDecode(iscrizione.p256dh);
const authSecret = base64UrlDecode(iscrizione.auth);
const salt = crypto.getRandomValues(new Uint8Array(16));
const effimera = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, [
"deriveBits",
]);
const asPublic = new Uint8Array(await crypto.subtle.exportKey("raw", effimera.publicKey));
const uaKey = await crypto.subtle.importKey(
"raw",
uaPublic as BufferSource,
{ name: "ECDH", namedCurve: "P-256" },
false,
[],
);
const condiviso = new Uint8Array(
await crypto.subtle.deriveBits({ name: "ECDH", public: uaKey }, effimera.privateKey, 256),
);
const ikm = await hkdf(
authSecret,
condiviso,
concat(etichetta("WebPush: info"), uaPublic, asPublic),
32,
);
const cek = await hkdf(salt, ikm, etichetta("Content-Encoding: aes128gcm"), 16);
const nonce = await hkdf(salt, ikm, etichetta("Content-Encoding: nonce"), 12);
// Il delimitatore 0x02 chiude l'ultimo (e unico) record: il testo sta sotto i 4 KB.
const chiaro = concat(new TextEncoder().encode(testoInChiaro), new Uint8Array([2]));
const aes = await crypto.subtle.importKey("raw", cek as BufferSource, "AES-GCM", false, [
"encrypt",
]);
const cifrato = new Uint8Array(
await crypto.subtle.encrypt(
{ name: "AES-GCM", iv: nonce as BufferSource },
aes,
chiaro as BufferSource,
),
);
// Intestazione RFC 8188: salt(16) | record size(4) | lunghezza chiave(1) | chiave(65).
const dimensioneRecord = new Uint8Array(4);
new DataView(dimensioneRecord.buffer).setUint32(0, 4096);
return concat(salt, dimensioneRecord, new Uint8Array([asPublic.length]), asPublic, cifrato);
}
/**
* Invia la notifica: titolo e testo viaggiano cifrati dentro la push.
*
* Torna anche il corpo della risposta, non solo lo stato: un servizio push che rifiuta
* spiega il perché lì dentro, e buttarlo via lasciava i guasti indistinguibili fra loro.
*/
export async function inviaPush(
iscrizione: IscrizionePush,
titolo: string,
testo: string,
): Promise<{ stato: number; corpo: string }> {
const publicKey = process.env["VAPID_PUBLIC_KEY"];
const privateKey = process.env["VAPID_PRIVATE_KEY"];
const subject = process.env["VAPID_SUBJECT"] ?? "mailto:crapp@crapvolley.it";
if (!publicKey || !privateKey) throw new Error("Chiavi VAPID non configurate");
const audience = new URL(endpoint).origin;
const audience = new URL(iscrizione.endpoint).origin;
const jwt = await creaVapidJwt(audience, subject, publicKey, privateKey);
const corpo = await cifraPayload(iscrizione, JSON.stringify({ title: titolo, body: testo }));
const res = await fetch(endpoint, {
const res = await fetch(iscrizione.endpoint, {
method: "POST",
headers: {
TTL: "86400",
// Senza `Urgency` il servizio push usa "normal", e un telefono in risparmio
// energetico (doze) accumula i messaggi normali fino al risveglio: la notifica
// arriva solo quando il dispositivo è già attivo, cioè quando l'app è aperta.
// "high" chiede la consegna immediata anche a schermo spento (RFC 8030 §5.3).
Urgency: "high",
Authorization: `vapid t=${jwt}, k=${publicKey}`,
"Content-Length": "0",
"Content-Encoding": "aes128gcm",
"Content-Type": "application/octet-stream",
},
body: corpo as BodyInit,
});
return res.status;
const risposta = (await res.text().catch(() => "")).slice(0, 500);
if (!res.ok) console.error("inviaPush", res.status, risposta);
return { stato: res.status, corpo: risposta };
}
src/routeTree.gen.ts
+17 -17
View File
@@ -24,7 +24,7 @@ import { Route as ApiPublicApriSondaggioRouteImport } from './routes/api/public/
import { Route as ApiPublicCsiRouteImport } from './routes/api/public/csi'
import { Route as ApiPublicPromemoriaPalloniRouteImport } from './routes/api/public/promemoria-palloni'
import { Route as ApiPublicPushConfigRouteImport } from './routes/api/public/push-config'
import { Route as ApiPublicPushMessaggioRouteImport } from './routes/api/public/push-messaggio'
import { Route as ApiPublicPushProvaRouteImport } from './routes/api/public/push-prova'
import { Route as ApiPublicPushSubscribeRouteImport } from './routes/api/public/push-subscribe'
import { Route as ApiPublicSollecitaPresenzeRouteImport } from './routes/api/public/sollecita-presenze'
@@ -104,9 +104,9 @@ const ApiPublicPushConfigRoute = ApiPublicPushConfigRouteImport.update({
path: '/api/public/push-config',
getParentRoute: () => rootRouteImport,
} as any)
const ApiPublicPushMessaggioRoute = ApiPublicPushMessaggioRouteImport.update({
id: '/api/public/push-messaggio',
path: '/api/public/push-messaggio',
const ApiPublicPushProvaRoute = ApiPublicPushProvaRouteImport.update({
id: '/api/public/push-prova',
path: '/api/public/push-prova',
getParentRoute: () => rootRouteImport,
} as any)
const ApiPublicPushSubscribeRoute = ApiPublicPushSubscribeRouteImport.update({
@@ -137,7 +137,7 @@ export interface FileRoutesByFullPath {
'/api/public/csi': typeof ApiPublicCsiRoute
'/api/public/promemoria-palloni': typeof ApiPublicPromemoriaPalloniRoute
'/api/public/push-config': typeof ApiPublicPushConfigRoute
'/api/public/push-messaggio': typeof ApiPublicPushMessaggioRoute
'/api/public/push-prova': typeof ApiPublicPushProvaRoute
'/api/public/push-subscribe': typeof ApiPublicPushSubscribeRoute
'/api/public/sollecita-presenze': typeof ApiPublicSollecitaPresenzeRoute
}
@@ -157,7 +157,7 @@ export interface FileRoutesByTo {
'/api/public/csi': typeof ApiPublicCsiRoute
'/api/public/promemoria-palloni': typeof ApiPublicPromemoriaPalloniRoute
'/api/public/push-config': typeof ApiPublicPushConfigRoute
'/api/public/push-messaggio': typeof ApiPublicPushMessaggioRoute
'/api/public/push-prova': typeof ApiPublicPushProvaRoute
'/api/public/push-subscribe': typeof ApiPublicPushSubscribeRoute
'/api/public/sollecita-presenze': typeof ApiPublicSollecitaPresenzeRoute
}
@@ -178,7 +178,7 @@ export interface FileRoutesById {
'/api/public/csi': typeof ApiPublicCsiRoute
'/api/public/promemoria-palloni': typeof ApiPublicPromemoriaPalloniRoute
'/api/public/push-config': typeof ApiPublicPushConfigRoute
'/api/public/push-messaggio': typeof ApiPublicPushMessaggioRoute
'/api/public/push-prova': typeof ApiPublicPushProvaRoute
'/api/public/push-subscribe': typeof ApiPublicPushSubscribeRoute
'/api/public/sollecita-presenze': typeof ApiPublicSollecitaPresenzeRoute
}
@@ -200,7 +200,7 @@ export interface FileRouteTypes {
| '/api/public/csi'
| '/api/public/promemoria-palloni'
| '/api/public/push-config'
| '/api/public/push-messaggio'
| '/api/public/push-prova'
| '/api/public/push-subscribe'
| '/api/public/sollecita-presenze'
fileRoutesByTo: FileRoutesByTo
@@ -220,7 +220,7 @@ export interface FileRouteTypes {
| '/api/public/csi'
| '/api/public/promemoria-palloni'
| '/api/public/push-config'
| '/api/public/push-messaggio'
| '/api/public/push-prova'
| '/api/public/push-subscribe'
| '/api/public/sollecita-presenze'
id:
@@ -240,7 +240,7 @@ export interface FileRouteTypes {
| '/api/public/csi'
| '/api/public/promemoria-palloni'
| '/api/public/push-config'
| '/api/public/push-messaggio'
| '/api/public/push-prova'
| '/api/public/push-subscribe'
| '/api/public/sollecita-presenze'
fileRoutesById: FileRoutesById
@@ -261,7 +261,7 @@ export interface RootRouteChildren {
ApiPublicCsiRoute: typeof ApiPublicCsiRoute
ApiPublicPromemoriaPalloniRoute: typeof ApiPublicPromemoriaPalloniRoute
ApiPublicPushConfigRoute: typeof ApiPublicPushConfigRoute
ApiPublicPushMessaggioRoute: typeof ApiPublicPushMessaggioRoute
ApiPublicPushProvaRoute: typeof ApiPublicPushProvaRoute
ApiPublicPushSubscribeRoute: typeof ApiPublicPushSubscribeRoute
ApiPublicSollecitaPresenzeRoute: typeof ApiPublicSollecitaPresenzeRoute
}
@@ -373,11 +373,11 @@ declare module '@tanstack/react-router' {
preLoaderRoute: typeof ApiPublicPushConfigRouteImport
parentRoute: typeof rootRouteImport
}
'/api/public/push-messaggio': {
id: '/api/public/push-messaggio'
path: '/api/public/push-messaggio'
fullPath: '/api/public/push-messaggio'
preLoaderRoute: typeof ApiPublicPushMessaggioRouteImport
'/api/public/push-prova': {
id: '/api/public/push-prova'
path: '/api/public/push-prova'
fullPath: '/api/public/push-prova'
preLoaderRoute: typeof ApiPublicPushProvaRouteImport
parentRoute: typeof rootRouteImport
}
'/api/public/push-subscribe': {
@@ -413,7 +413,7 @@ const rootRouteChildren: RootRouteChildren = {
ApiPublicCsiRoute: ApiPublicCsiRoute,
ApiPublicPromemoriaPalloniRoute: ApiPublicPromemoriaPalloniRoute,
ApiPublicPushConfigRoute: ApiPublicPushConfigRoute,
ApiPublicPushMessaggioRoute: ApiPublicPushMessaggioRoute,
ApiPublicPushProvaRoute: ApiPublicPushProvaRoute,
ApiPublicPushSubscribeRoute: ApiPublicPushSubscribeRoute,
ApiPublicSollecitaPresenzeRoute: ApiPublicSollecitaPresenzeRoute,
}
src/routes/__root.tsx
+3
View File
@@ -19,6 +19,7 @@ import { Toaster } from "../components/ui/sonner";
import { TeamLogo } from "../components/crapp/ui-bits";
import { useGiocatoreBase } from "../lib/user-store";
import { useSessione } from "../lib/auth";
import { mantieniWorkerPushAggiornato } from "../lib/push-client";
function NotFoundComponent() {
return (
@@ -175,6 +176,8 @@ function AppShell() {
const [mounted, setMounted] = useState(false);
const isBenvenuto = location.pathname === "/benvenuto";
useEffect(mantieniWorkerPushAggiornato, []);
// Senza sessione Google non si entra: l'identità la dà il login, non la scelta del nome
// (DD-011). Si aspetta `pronta`, altrimenti il primo render sloggato rimbalzerebbe fuori
// chi ha già la sessione in localStorage.
src/routes/api/public/apri-sondaggio.ts
+2 -5
View File
@@ -24,7 +24,7 @@ export const Route = createFileRoute("/api/public/apri-sondaggio")({
const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
const { data: iscrizioni } = await supabaseAdmin
.from("push_subscriptions")
.select("endpoint");
.select("endpoint, p256dh, auth");
const titolo = "💩 Sondaggio pre-partita aperto";
const testo = `${partita.titolo} · ore ${partita.ora}. Quante cacche hai fatto? Rispondi prima del fischio d'inizio.`;
@@ -32,10 +32,7 @@ export const Route = createFileRoute("/api/public/apri-sondaggio")({
let inviate = 0;
for (const iscrizione of iscrizioni ?? []) {
try {
await supabaseAdmin
.from("promemoria_push")
.insert({ endpoint: iscrizione.endpoint, titolo, testo });
const stato = await inviaPush(iscrizione.endpoint);
const { stato } = await inviaPush(iscrizione, titolo, testo);
if (stato === 404 || stato === 410) {
await supabaseAdmin
.from("push_subscriptions")
src/routes/api/public/promemoria-palloni.ts
+3 -9
View File
@@ -11,8 +11,7 @@ const schema = z.object({ eventoId: z.string().min(1).max(50) });
/**
* Promemoria del turno palloni per un evento: lo fa partire un admin dalla pagina
* dell'evento (DD-025). Il testo va in coda su `promemoria_push` perché la push parte
* vuota e il service worker chiede a `push-messaggio` cosa mostrare.
* dell'evento (DD-025). Il testo viaggia cifrato dentro la push.
*/
export const Route = createFileRoute("/api/public/promemoria-palloni")({
server: {
@@ -47,7 +46,7 @@ export const Route = createFileRoute("/api/public/promemoria-palloni")({
const { data: iscrizioni } = await supabaseAdmin
.from("push_subscriptions")
.select("endpoint, giocatore_id")
.select("endpoint, giocatore_id, p256dh, auth")
.in(
"giocatore_id",
avvisi.map((a) => a.giocatoreId),
@@ -58,12 +57,7 @@ export const Route = createFileRoute("/api/public/promemoria-palloni")({
const avviso = avvisi.find((a) => a.giocatoreId === iscrizione.giocatore_id);
if (!avviso) continue;
try {
await supabaseAdmin.from("promemoria_push").insert({
endpoint: iscrizione.endpoint,
titolo: avviso.titolo,
testo: avviso.testo,
});
const stato = await inviaPush(iscrizione.endpoint);
const { stato } = await inviaPush(iscrizione, avviso.titolo, avviso.testo);
if (stato === 404 || stato === 410) {
await supabaseAdmin
.from("push_subscriptions")
src/routes/api/public/push-messaggio.ts
-67
View File
@@ -1,67 +0,0 @@
import { createFileRoute } from "@tanstack/react-router";
import { z } from "zod";
import { nomeCompleto } from "@/lib/giocatori-squadra";
import { leggiGiocatoriSquadra } from "@/lib/giocatori-squadra.server";
import { completaTurni, messaggioPalloniOggi, oggiISO } from "@/lib/palloni-core";
import { leggiEventi } from "@/lib/eventi.server";
import { promemoriaAncoraValido } from "@/lib/webpush.server";
const schema = z.object({ endpoint: z.string().url().max(1000) });
export const Route = createFileRoute("/api/public/push-messaggio")({
server: {
handlers: {
POST: async ({ request }) => {
const parsed = schema.safeParse(await request.json());
if (!parsed.success) return new Response("Dati non validi", { status: 400 });
const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
// Messaggio in coda (es. sollecito presenze): ha la precedenza e viene consumato.
const { data: promemoria } = await supabaseAdmin
.from("promemoria_push")
.select("id, titolo, testo, creato_il")
.eq("endpoint", parsed.data.endpoint)
.order("creato_il", { ascending: false })
.limit(1)
.maybeSingle();
if (promemoria) {
// La coda si svuota comunque, anche quando il messaggio è vecchio: altrimenti
// resterebbe lì a dirottare la prossima notifica di qualunque tipo.
await supabaseAdmin.from("promemoria_push").delete().eq("endpoint", parsed.data.endpoint);
if (promemoriaAncoraValido(promemoria.creato_il)) {
return Response.json({ title: promemoria.titolo, body: promemoria.testo });
}
}
const { data: iscrizione } = await supabaseAdmin
.from("push_subscriptions")
.select("giocatore_id")
.eq("endpoint", parsed.data.endpoint)
.maybeSingle();
if (!iscrizione)
return Response.json({ title: "CrAPP", body: "Controlla il turno palloni." });
const { data: righe } = await supabaseAdmin
.from("turni_palloni")
.select("evento_id, giocatore_id");
const salvati: Record<string, string> = {};
for (const riga of righe ?? []) salvati[riga.evento_id] = riga.giocatore_id;
const eventi = await leggiEventi();
const squadra = await leggiGiocatoriSquadra();
const rosa = squadra
.filter((g) => g.attivo)
.map((g) => ({ id: g.id, nome: nomeCompleto(g) }));
const turni = completaTurni(salvati, eventi, rosa);
const oggi = oggiISO();
const mioId = iscrizione.giocatore_id;
const giocatore = squadra.find((g) => g.id === mioId);
const nome = giocatore ? nomeCompleto(giocatore) : "";
return Response.json(messaggioPalloniOggi(turni, eventi, oggi, mioId, nome));
},
},
},
});
src/routes/api/public/push-prova.ts
+54
View File
@@ -0,0 +1,54 @@
import { createFileRoute } from "@tanstack/react-router";
import { z } from "zod";
import { inviaPush } from "@/lib/webpush.server";
const schema = z.object({ endpoint: z.string().url().max(1000) });
/**
* Manda una push di prova al dispositivo che la chiede, e racconta com'è andata.
*
* Serve a rendere osservabile un guasto che finora si vedeva solo come "non arriva":
* senza questa route ogni prova richiede un admin, un evento nello stato giusto e una
* seconda persona, e la risposta del servizio push viene buttata via. Qui invece si vede
* lo stato HTTP, il corpo della risposta e se l'endpoint è davvero quello registrato in
* `push_subscriptions` — cioè se il server sta parlando con questo telefono o con una
* vecchia iscrizione morta.
*
* Nessun controllo di accesso, come per `push-config` e `push-subscribe`: manda solo
* all'endpoint che il chiamante fornisce, quindi al massimo si sveglia da solo. È un URL
* segreto per dispositivo, e chi lo conosce lo ha già.
*/
export const Route = createFileRoute("/api/public/push-prova")({
server: {
handlers: {
POST: async ({ request }) => {
const parsed = schema.safeParse(await request.json());
if (!parsed.success) return new Response("Dati non validi", { status: 400 });
const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
const { data: iscrizione } = await supabaseAdmin
.from("push_subscriptions")
.select("endpoint, p256dh, auth")
.eq("endpoint", parsed.data.endpoint)
.maybeSingle();
if (!iscrizione) {
// Il dispositivo ha una sottoscrizione che il database non conosce: la push non
// partirebbe mai da sola, perché i mittenti leggono solo da qui.
return Response.json({
nelDatabase: false,
stato: 0,
corpo: "Questo dispositivo non risulta iscritto: riattiva le notifiche.",
});
}
const { stato, corpo } = await inviaPush(
iscrizione,
"🔔 Notifica di prova",
`Inviata alle ${new Date().toLocaleTimeString("it-IT")}. Se la leggi ad app chiusa, il canale funziona.`,
);
return Response.json({ nelDatabase: true, stato, corpo });
},
},
},
});
src/routes/api/public/sollecita-presenze.ts
+2 -5
View File
@@ -46,7 +46,7 @@ export const Route = createFileRoute("/api/public/sollecita-presenze")({
const { data: iscrizioni } = await supabaseAdmin
.from("push_subscriptions")
.select("endpoint, giocatore_id")
.select("endpoint, p256dh, auth")
.in("giocatore_id", destinatari);
const titolo = "Manca la tua risposta";
@@ -57,10 +57,7 @@ export const Route = createFileRoute("/api/public/sollecita-presenze")({
let inviate = 0;
for (const iscrizione of iscrizioni ?? []) {
try {
await supabaseAdmin
.from("promemoria_push")
.insert({ endpoint: iscrizione.endpoint, titolo, testo });
const stato = await inviaPush(iscrizione.endpoint);
const { stato } = await inviaPush(iscrizione, titolo, testo);
if (stato === 404 || stato === 410) {
await supabaseAdmin
.from("push_subscriptions")
src/routes/profilo.tsx
+47 -1
View File
@@ -1,7 +1,17 @@
import { createFileRoute, Link } from "@tanstack/react-router";
import { useEffect, useRef, useState } from "react";
import { toast } from "sonner";
import { Flame, Camera, Trash2, Bell, LogOut, ShieldCheck, Bug, Lightbulb } from "lucide-react";
import {
Flame,
Camera,
Trash2,
Bell,
BellRing,
LogOut,
ShieldCheck,
Bug,
Lightbulb,
} from "lucide-react";
import { cn } from "@/lib/utils";
import { Card, PageHeader, StatTile, TeamLogo } from "@/components/crapp/ui-bits";
import { BarraSottosezioni } from "@/components/crapp/BarraSottosezioni";
@@ -21,6 +31,7 @@ import { usePresenzeUltimoMese } from "@/lib/presenze-mese";
import {
attivaNotifiche,
disattivaNotifiche,
notificaDiProva,
pushSupportato,
statoNotifiche,
} from "@/lib/push-client";
@@ -72,6 +83,7 @@ function Profilo() {
const [bust, setBust] = useState(0);
const [notifiche, setNotifiche] = useState(false);
const [inCorso, setInCorso] = useState(false);
const [inProva, setInProva] = useState(false);
const [supportate, setSupportate] = useState(true);
useEffect(() => {
@@ -103,6 +115,22 @@ function Profilo() {
}
}
async function provaNotifica() {
if (inProva) return;
setInProva(true);
try {
const esito = await notificaDiProva();
if (!esito.nelDatabase) toast.error(esito.corpo);
else if (esito.stato >= 200 && esito.stato < 300)
toast.success("Push accettata dal servizio: verifica la notifica sul dispositivo");
else toast.error(`Il servizio push ha risposto ${esito.stato}: ${esito.corpo}`);
} catch (error) {
toast.error(error instanceof Error ? error.message : "Prova non riuscita");
} finally {
setInProva(false);
}
}
async function logout() {
try {
await esci();
@@ -271,6 +299,24 @@ function Profilo() {
<Bell className="h-4 w-4" />
</span>
</button>
{notifiche ? (
<button
type="button"
onClick={provaNotifica}
disabled={inProva}
className="flex min-h-11 w-full items-center justify-between gap-3 px-4 py-3 text-left text-sm disabled:opacity-60"
>
<span className="min-w-0">
<span className="block truncate">Mandami una notifica di prova</span>
<span className="block text-xs text-muted-foreground">
Invia subito una push a questo dispositivo
</span>
</span>
<span className="grid h-8 w-8 shrink-0 place-items-center rounded-xl bg-secondary text-muted-foreground">
<BellRing className="h-4 w-4" />
</span>
</button>
) : null}
{admin ? (
<Link
to="/admin"