davideandClaude Opus 5
d8f334007b
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>
79 lines
3.0 KiB
TypeScript
79 lines
3.0 KiB
TypeScript
import { createFileRoute } from "@tanstack/react-router";
|
|
import { z } from "zod";
|
|
import { richiediAdmin } from "@/lib/auth-route.server";
|
|
import { nomeCompleto } from "@/lib/giocatori-squadra";
|
|
import { leggiGiocatoriSquadra } from "@/lib/giocatori-squadra.server";
|
|
import { avvisiPalloniEvento, completaTurni } from "@/lib/palloni-core";
|
|
import { inviaPush } from "@/lib/webpush.server";
|
|
import { leggiEventi } from "@/lib/eventi.server";
|
|
|
|
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 viaggia cifrato dentro la push.
|
|
*/
|
|
export const Route = createFileRoute("/api/public/promemoria-palloni")({
|
|
server: {
|
|
handlers: {
|
|
POST: async ({ request }) => {
|
|
const negato = await richiediAdmin(request);
|
|
if (negato) return negato;
|
|
|
|
const parsed = schema.safeParse(await request.json());
|
|
if (!parsed.success) return new Response("Dati non validi", { status: 400 });
|
|
|
|
const eventi = await leggiEventi();
|
|
const evento = eventi.find((e) => e.id === parsed.data.eventoId);
|
|
if (!evento) return new Response("Evento non trovato", { status: 404 });
|
|
|
|
const { supabaseAdmin } = await import("@/integrations/supabase/client.server");
|
|
|
|
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 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 avvisi = avvisiPalloniEvento(turni, eventi, evento.id);
|
|
if (avvisi.length === 0) return Response.json({ inviate: 0, destinatari: 0 });
|
|
|
|
const { data: iscrizioni } = await supabaseAdmin
|
|
.from("push_subscriptions")
|
|
.select("endpoint, giocatore_id, p256dh, auth")
|
|
.in(
|
|
"giocatore_id",
|
|
avvisi.map((a) => a.giocatoreId),
|
|
);
|
|
|
|
let inviate = 0;
|
|
for (const iscrizione of iscrizioni ?? []) {
|
|
const avviso = avvisi.find((a) => a.giocatoreId === iscrizione.giocatore_id);
|
|
if (!avviso) continue;
|
|
try {
|
|
const { stato } = await inviaPush(iscrizione, avviso.titolo, avviso.testo);
|
|
if (stato === 404 || stato === 410) {
|
|
await supabaseAdmin
|
|
.from("push_subscriptions")
|
|
.delete()
|
|
.eq("endpoint", iscrizione.endpoint);
|
|
} else if (stato >= 200 && stato < 300) {
|
|
inviate += 1;
|
|
}
|
|
} catch (error) {
|
|
console.error("promemoria-palloni", error);
|
|
}
|
|
}
|
|
|
|
return Response.json({ inviate, destinatari: (iscrizioni ?? []).length });
|
|
},
|
|
},
|
|
},
|
|
});
|