|
|
|
@@ -1,7 +1,15 @@
|
|
|
|
|
// Edge Function `admin-gallery`
|
|
|
|
|
//
|
|
|
|
|
// Contrat (fixé par le chef de projet, à ne pas renommer) :
|
|
|
|
|
// GET {SUPABASE_URL}/functions/v1/admin-gallery?slug=<slug>&token=<admin_token>[&action=zip]
|
|
|
|
|
// GET {SUPABASE_URL}/functions/v1/admin-gallery?slug=<slug>&token=<admin_token>
|
|
|
|
|
// -> JSON galerie (+ zip_parts : nombre de parties du ZIP)
|
|
|
|
|
// GET ...&action=zip&part=<1..zip_parts> -> ZIP d'une partie (flux)
|
|
|
|
|
// POST ...&action=delete&photo_id=<uuid> -> supprime une photo (B1)
|
|
|
|
|
//
|
|
|
|
|
// ⚠️ Déploiement : verify_jwt = false requis. Les parties du ZIP sont des
|
|
|
|
|
// liens directs (<a href>) que le navigateur télécharge en flux, sans header
|
|
|
|
|
// Authorization possible. La clé publishable n'apportait aucune sécurité
|
|
|
|
|
// (publique) : l'accès repose sur admin_token, vérifié ci-dessous.
|
|
|
|
|
//
|
|
|
|
|
// Tourne avec la service_role key (cf. _shared/supabase-admin.ts).
|
|
|
|
|
//
|
|
|
|
@@ -25,10 +33,10 @@
|
|
|
|
|
// (cf. plus bas, section `action=zip`). Non testée en exécution dans cet
|
|
|
|
|
// environnement (pas d'accès réseau/deploy) — à valider avec
|
|
|
|
|
// `supabase functions serve` avant premier déploiement réel.
|
|
|
|
|
import { getSupabaseAdmin, getStorageBucket } from "../_shared/supabase-admin.ts";
|
|
|
|
|
import { getSupabaseAdmin, getStorageBucket, thumbPathOf } from "../_shared/supabase-admin.ts";
|
|
|
|
|
import { corsHeaders, handleCorsPreflight } from "../_shared/cors.ts";
|
|
|
|
|
import { timingSafeEqual } from "../_shared/timing-safe.ts";
|
|
|
|
|
import { HttpReader, ZipWriter } from "jsr:@zip-js/zip-js";
|
|
|
|
|
import { TextReader, Uint8ArrayReader, ZipWriter } from "jsr:@zip-js/zip-js";
|
|
|
|
|
|
|
|
|
|
// URL signées affichées dans la galerie admin : courte durée, c'est pour un
|
|
|
|
|
// affichage/téléchargement immédiat dans le navigateur de l'admin, pas pour
|
|
|
|
@@ -41,11 +49,16 @@ const GALLERY_SIGNED_URL_TTL_SECONDS = 10 * 60; // 10 minutes
|
|
|
|
|
// du ZIP en cas de gros volume.
|
|
|
|
|
const ZIP_INTERNAL_SIGNED_URL_TTL_SECONDS = 30 * 60; // 30 minutes
|
|
|
|
|
|
|
|
|
|
// Garde-fou volume ZIP (placeholder, non validé empiriquement — cf. rapport
|
|
|
|
|
// de tâche) : au-delà, on refuse `action=zip` plutôt que de risquer un
|
|
|
|
|
// timeout Edge Function (~150s) ou un flux qui traîne indéfiniment. À
|
|
|
|
|
// ajuster une fois testé avec un volume réel de photos.
|
|
|
|
|
const MAX_ZIP_PHOTOS = 400;
|
|
|
|
|
// Découpage du ZIP en parties (audit B3). Limite Supabase (doc "Edge
|
|
|
|
|
// Functions > Limits", lue le 2026-10-15) : 150 s de durée max par worker en
|
|
|
|
|
// plan Free (400 s en payant), 256 Mo de RAM, 2 s de CPU. Une partie doit
|
|
|
|
|
// donc être téléchargée en entier en < 150 s par le client : 100 Mo
|
|
|
|
|
// demandent ~5,5 Mbit/s soutenus. Plafond en nombre aussi (1 requête
|
|
|
|
|
// Storage par photo). Plan payant : on peut monter à ~250 Mo.
|
|
|
|
|
const MAX_ZIP_PART_BYTES = 100 * 1024 * 1024;
|
|
|
|
|
const MAX_ZIP_PART_PHOTOS = 300;
|
|
|
|
|
|
|
|
|
|
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
|
|
|
|
|
|
|
|
function jsonResponse(status: number, body: unknown): Response {
|
|
|
|
|
return new Response(JSON.stringify(body), {
|
|
|
|
@@ -97,8 +110,33 @@ type PhotoRow = {
|
|
|
|
|
message: string | null;
|
|
|
|
|
uploaded_at: string;
|
|
|
|
|
url_storage: string;
|
|
|
|
|
size_bytes: number;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Découpage glouton dans l'ordre stable (uploaded_at, id) : renvoie l'index
|
|
|
|
|
// de début de chaque partie. Un ajout de photo ne change que la dernière
|
|
|
|
|
// partie ; une suppression décale les parties suivantes (le front le dit).
|
|
|
|
|
function zipPartStarts(photos: PhotoRow[]): number[] {
|
|
|
|
|
const starts: number[] = [];
|
|
|
|
|
let bytes = 0;
|
|
|
|
|
let count = 0;
|
|
|
|
|
for (let i = 0; i < photos.length; i++) {
|
|
|
|
|
const size = Number(photos[i].size_bytes) || 0;
|
|
|
|
|
if (
|
|
|
|
|
starts.length === 0 ||
|
|
|
|
|
count >= MAX_ZIP_PART_PHOTOS ||
|
|
|
|
|
(count > 0 && bytes + size > MAX_ZIP_PART_BYTES)
|
|
|
|
|
) {
|
|
|
|
|
starts.push(i);
|
|
|
|
|
bytes = 0;
|
|
|
|
|
count = 0;
|
|
|
|
|
}
|
|
|
|
|
bytes += size;
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
return starts;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type AdminEventRow = {
|
|
|
|
|
id: string;
|
|
|
|
|
nom: string;
|
|
|
|
@@ -120,15 +158,18 @@ Deno.serve(async (req) => {
|
|
|
|
|
const preflight = handleCorsPreflight(req);
|
|
|
|
|
if (preflight) return preflight;
|
|
|
|
|
|
|
|
|
|
if (req.method !== "GET") {
|
|
|
|
|
return jsonResponse(405, { error: "method_not_allowed" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const url = new URL(req.url);
|
|
|
|
|
const slug = url.searchParams.get("slug");
|
|
|
|
|
const token = url.searchParams.get("token");
|
|
|
|
|
const action = url.searchParams.get("action");
|
|
|
|
|
|
|
|
|
|
// Suppression = POST uniquement (jamais un GET qu'un préchargement ou un
|
|
|
|
|
// robot pourrait déclencher) ; tout le reste = GET.
|
|
|
|
|
const expectedMethod = action === "delete" ? "POST" : "GET";
|
|
|
|
|
if (req.method !== expectedMethod) {
|
|
|
|
|
return jsonResponse(405, { error: "method_not_allowed" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!slug || !token) {
|
|
|
|
|
return jsonResponse(400, { error: "missing_parameters" });
|
|
|
|
|
}
|
|
|
|
@@ -174,7 +215,22 @@ Deno.serve(async (req) => {
|
|
|
|
|
// 20260916090400_create_public_functions.sql), on réutilise donc
|
|
|
|
|
// directement celui de la query string plutôt que de modifier la RPC
|
|
|
|
|
// pour ça.
|
|
|
|
|
return await handleZipExport(supabaseAdmin, bucket, typedEvent, slug);
|
|
|
|
|
return await handleZipExport(
|
|
|
|
|
supabaseAdmin,
|
|
|
|
|
bucket,
|
|
|
|
|
typedEvent,
|
|
|
|
|
slug,
|
|
|
|
|
url.searchParams.get("part")
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (action === "delete") {
|
|
|
|
|
return await handleDeletePhoto(
|
|
|
|
|
supabaseAdmin,
|
|
|
|
|
bucket,
|
|
|
|
|
typedEvent,
|
|
|
|
|
url.searchParams.get("photo_id")
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return await handleJsonGallery(supabaseAdmin, typedEvent);
|
|
|
|
@@ -185,11 +241,12 @@ async function fetchEventPhotos(
|
|
|
|
|
supabaseAdmin: any,
|
|
|
|
|
eventId: string
|
|
|
|
|
): Promise<PhotoRow[]> {
|
|
|
|
|
// public.get_event_photos (service_role uniquement) renvoie les photos
|
|
|
|
|
// triées par uploaded_at ASC (ordre chronologique), cf.
|
|
|
|
|
// 20260916090400_create_public_functions.sql.
|
|
|
|
|
const { data, error } = await supabaseAdmin.rpc("get_event_photos", {
|
|
|
|
|
// public.get_event_photos_admin (service_role uniquement) : photos triées
|
|
|
|
|
// par uploaded_at ASC puis id, avec la taille du fichier, cf.
|
|
|
|
|
// 20261015120000_admin_delete_photo_and_zip_sizes.sql.
|
|
|
|
|
const { data, error } = await supabaseAdmin.rpc("get_event_photos_admin", {
|
|
|
|
|
p_event_id: eventId,
|
|
|
|
|
p_bucket: getStorageBucket(),
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
@@ -215,7 +272,7 @@ async function handleJsonGallery(
|
|
|
|
|
// Galerie admin : plus récent en premier. get_event_photos renvoie déjà
|
|
|
|
|
// un tableau trié ASC (chronologique) ; on l'inverse ici plutôt que
|
|
|
|
|
// d'ajouter un paramètre d'ordre à la RPC (le volume par événement reste
|
|
|
|
|
// modeste, cf. MAX_ZIP_PHOTOS = 400, donc un `.reverse()` en mémoire est
|
|
|
|
|
// modeste, quelques milliers au plus, donc un `.reverse()` en mémoire est
|
|
|
|
|
// largement suffisant).
|
|
|
|
|
const photosDesc = [...photosAsc].reverse();
|
|
|
|
|
|
|
|
|
@@ -223,12 +280,16 @@ async function handleJsonGallery(
|
|
|
|
|
// plutôt qu'un appel par photo : moins de requêtes réseau, cohérent avec
|
|
|
|
|
// le principe d'écoconception du projet (CLAUDE.md).
|
|
|
|
|
const signedUrlBypath = new Map<string, string>();
|
|
|
|
|
const thumbUrlByPath = new Map<string, string>();
|
|
|
|
|
if (photosDesc.length > 0) {
|
|
|
|
|
const paths = photosDesc.map((p) => p.url_storage);
|
|
|
|
|
const bucket = getStorageBucket();
|
|
|
|
|
const { data: signedUrls, error: signError } = await supabaseAdmin.storage
|
|
|
|
|
.from(bucket)
|
|
|
|
|
.createSignedUrls(paths, GALLERY_SIGNED_URL_TTL_SECONDS);
|
|
|
|
|
// Originaux + miniatures en une seule requête. Miniature absente
|
|
|
|
|
// (photo d'avant les miniatures, échec côté invité) : entrée en erreur,
|
|
|
|
|
// thumb_url null, le front affiche l'original.
|
|
|
|
|
.createSignedUrls([...paths, ...paths.map(thumbPathOf)], GALLERY_SIGNED_URL_TTL_SECONDS);
|
|
|
|
|
|
|
|
|
|
if (signError) {
|
|
|
|
|
console.error("[admin-gallery] createSignedUrls failed", signError);
|
|
|
|
@@ -236,6 +297,8 @@ async function handleJsonGallery(
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (let i = 0; i < paths.length; i++) {
|
|
|
|
|
const thumbUrl = signedUrls?.[paths.length + i]?.signedUrl;
|
|
|
|
|
if (thumbUrl) thumbUrlByPath.set(paths[i], thumbUrl);
|
|
|
|
|
const entry = signedUrls?.[i];
|
|
|
|
|
if (entry?.signedUrl) {
|
|
|
|
|
signedUrlBypath.set(paths[i], entry.signedUrl);
|
|
|
|
@@ -259,12 +322,14 @@ async function handleJsonGallery(
|
|
|
|
|
statut: event.statut,
|
|
|
|
|
photo_count: photosDesc.length,
|
|
|
|
|
},
|
|
|
|
|
zip_parts: zipPartStarts(photosAsc).length,
|
|
|
|
|
photos: photosDesc.map((p) => ({
|
|
|
|
|
id: p.id,
|
|
|
|
|
nom_invite: p.nom_invite,
|
|
|
|
|
message: p.message,
|
|
|
|
|
uploaded_at: p.uploaded_at,
|
|
|
|
|
signed_url: signedUrlBypath.get(p.url_storage) ?? null,
|
|
|
|
|
thumb_url: thumbUrlByPath.get(p.url_storage) ?? null,
|
|
|
|
|
expires_in: GALLERY_SIGNED_URL_TTL_SECONDS,
|
|
|
|
|
})),
|
|
|
|
|
});
|
|
|
|
@@ -275,31 +340,31 @@ async function handleZipExport(
|
|
|
|
|
supabaseAdmin: any,
|
|
|
|
|
bucket: string,
|
|
|
|
|
event: AdminEventRow,
|
|
|
|
|
slug: string
|
|
|
|
|
slug: string,
|
|
|
|
|
partParam: string | null
|
|
|
|
|
): Promise<Response> {
|
|
|
|
|
let photos: PhotoRow[];
|
|
|
|
|
let allPhotos: PhotoRow[];
|
|
|
|
|
try {
|
|
|
|
|
photos = await fetchEventPhotos(supabaseAdmin, event.id);
|
|
|
|
|
allPhotos = await fetchEventPhotos(supabaseAdmin, event.id);
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.error("[admin-gallery] zip: get_event_photos failed", err);
|
|
|
|
|
return jsonResponse(500, { error: "internal_error" });
|
|
|
|
|
console.error("[admin-gallery] zip: get_event_photos_admin failed", err);
|
|
|
|
|
return textResponse(500, "Le service est momentanément indisponible. Réessaie dans quelques instants.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (photos.length === 0) {
|
|
|
|
|
return jsonResponse(404, { error: "no_photos" });
|
|
|
|
|
if (allPhotos.length === 0) {
|
|
|
|
|
return textResponse(404, "Il n'y a aucune photo à télécharger pour cet événement.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Garde-fou volume (cf. MAX_ZIP_PHOTOS ci-dessus) : évite de partir sur un
|
|
|
|
|
// ZIP qui a de bonnes chances de timeout côté Edge Function pour un très
|
|
|
|
|
// gros événement. Valeur provisoire, à valider avec un test réel — cf.
|
|
|
|
|
// rapport de tâche.
|
|
|
|
|
if (photos.length > MAX_ZIP_PHOTOS) {
|
|
|
|
|
return jsonResponse(413, {
|
|
|
|
|
error: "too_many_photos_for_zip",
|
|
|
|
|
photo_count: photos.length,
|
|
|
|
|
max_zip_photos: MAX_ZIP_PHOTOS,
|
|
|
|
|
});
|
|
|
|
|
const starts = zipPartStarts(allPhotos);
|
|
|
|
|
const part = partParam === null ? 1 : Number(partParam);
|
|
|
|
|
if (!Number.isInteger(part) || part < 1 || part > starts.length) {
|
|
|
|
|
return textResponse(
|
|
|
|
|
404,
|
|
|
|
|
`Cette partie du ZIP n'existe plus (l'export compte ${starts.length} partie(s)). Retourne sur la galerie et clique sur "Actualiser".`
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
const offset = starts[part - 1];
|
|
|
|
|
const photos = allPhotos.slice(offset, starts[part] ?? allPhotos.length);
|
|
|
|
|
|
|
|
|
|
const paths = photos.map((p) => p.url_storage);
|
|
|
|
|
const { data: signedUrls, error: signError } = await supabaseAdmin.storage
|
|
|
|
@@ -308,18 +373,23 @@ async function handleZipExport(
|
|
|
|
|
|
|
|
|
|
if (signError) {
|
|
|
|
|
console.error("[admin-gallery] zip: createSignedUrls failed", signError);
|
|
|
|
|
return jsonResponse(500, { error: "internal_error" });
|
|
|
|
|
return textResponse(500, "Le service est momentanément indisponible. Réessaie dans quelques instants.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Construction du ZIP en FLUX (pas de Blob/Uint8Array accumulé en mémoire
|
|
|
|
|
// pour l'ensemble des photos) : on écrit dans un TransformStream, et on
|
|
|
|
|
// renvoie sa moitié "readable" comme corps de la Response immédiatement,
|
|
|
|
|
// pendant que la moitié "writable" continue de recevoir les fichiers
|
|
|
|
|
// (téléchargés directement depuis Storage via HttpReader). `level: 0`
|
|
|
|
|
// (lus un par un depuis Storage, cf. fetchPhotoBytes). `level: 0`
|
|
|
|
|
// (STORE, pas de compression) : les photos sont déjà des JPEG compressés
|
|
|
|
|
// côté client (cf. src/e/upload.js), les recompresser dans le ZIP
|
|
|
|
|
// coûterait du CPU pour un gain quasi nul.
|
|
|
|
|
const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>();
|
|
|
|
|
let streamController!: TransformStreamDefaultController<Uint8Array>;
|
|
|
|
|
const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>({
|
|
|
|
|
start(controller) {
|
|
|
|
|
streamController = controller;
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
const zipWriter = new ZipWriter(writable);
|
|
|
|
|
|
|
|
|
|
const usedNames = new Set<string>();
|
|
|
|
@@ -328,49 +398,63 @@ async function handleZipExport(
|
|
|
|
|
// `return new Response(readable, ...)`, sinon on perdrait l'intérêt du
|
|
|
|
|
// streaming. La fonction Edge reste vivante tant que la réponse en
|
|
|
|
|
// streaming n'est pas entièrement consommée par le client.
|
|
|
|
|
// Photo illisible (Storage en erreur, fichier disparu) : on la saute et on
|
|
|
|
|
// la liste dans PHOTOS-MANQUANTES.txt à la fin du ZIP. Une fois le 200
|
|
|
|
|
// envoyé, on ne peut plus signaler d'erreur HTTP, et faire échouer le flux
|
|
|
|
|
// ne coupe pas la connexion (testé en local : téléchargement suspendu
|
|
|
|
|
// jusqu'au kill du worker à 150 s). Chaque photo est lue en entier
|
|
|
|
|
// (<= 6 Mo, cf. src/e/upload.js) AVANT d'être ajoutée : un échec de
|
|
|
|
|
// lecture ne peut donc pas laisser une entrée à moitié écrite.
|
|
|
|
|
const missing: string[] = [];
|
|
|
|
|
|
|
|
|
|
(async () => {
|
|
|
|
|
try {
|
|
|
|
|
for (let i = 0; i < photos.length; i++) {
|
|
|
|
|
const photo = photos[i];
|
|
|
|
|
const signed = signedUrls?.[i];
|
|
|
|
|
if (!signed?.signedUrl) {
|
|
|
|
|
console.warn(
|
|
|
|
|
`[admin-gallery] zip: skipping ${photo.url_storage} (no signed url)`
|
|
|
|
|
);
|
|
|
|
|
const bytes = signed?.signedUrl ? await fetchPhotoBytes(signed.signedUrl) : null;
|
|
|
|
|
if (!bytes) {
|
|
|
|
|
console.warn(`[admin-gallery] zip: missing ${photo.url_storage}`);
|
|
|
|
|
missing.push(`${photo.nom_invite ?? "invité anonyme"}, ${photo.uploaded_at} (id ${photo.id})`);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const ext = extensionFromPath(photo.url_storage);
|
|
|
|
|
let entryName = buildZipEntryName(photo, i, ext);
|
|
|
|
|
// Index global (offset + i) : noms uniques d'une partie à l'autre.
|
|
|
|
|
let entryName = buildZipEntryName(photo, offset + i, ext);
|
|
|
|
|
// Garantit l'unicité même en cas de collision improbable.
|
|
|
|
|
let suffix = 1;
|
|
|
|
|
while (usedNames.has(entryName)) {
|
|
|
|
|
entryName = `${buildZipEntryName(photo, i, ext).replace(`.${ext}`, "")}-${suffix}.${ext}`;
|
|
|
|
|
entryName = `${buildZipEntryName(photo, offset + i, ext).replace(`.${ext}`, "")}-${suffix}.${ext}`;
|
|
|
|
|
suffix++;
|
|
|
|
|
}
|
|
|
|
|
usedNames.add(entryName);
|
|
|
|
|
|
|
|
|
|
await zipWriter.add(entryName, new HttpReader(signed.signedUrl), {
|
|
|
|
|
await zipWriter.add(entryName, new Uint8ArrayReader(bytes), {
|
|
|
|
|
level: 0,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
} catch (err) {
|
|
|
|
|
// ⚠️ Limite connue : si une erreur survient APRÈS que les premiers
|
|
|
|
|
// octets de la réponse ont déjà été envoyés (statut 200 déjà commis),
|
|
|
|
|
// il est impossible de renvoyer un statut d'erreur HTTP à ce stade.
|
|
|
|
|
// Le client reçoit un ZIP tronqué/corrompu plutôt qu'un message
|
|
|
|
|
// d'erreur propre — limite inhérente au streaming HTTP.
|
|
|
|
|
console.error("[admin-gallery] zip: stream build failed", err);
|
|
|
|
|
} finally {
|
|
|
|
|
try {
|
|
|
|
|
await zipWriter.close();
|
|
|
|
|
} catch (closeErr) {
|
|
|
|
|
console.error("[admin-gallery] zip: writer close failed", closeErr);
|
|
|
|
|
if (missing.length > 0) {
|
|
|
|
|
await zipWriter.add(
|
|
|
|
|
"PHOTOS-MANQUANTES.txt",
|
|
|
|
|
new TextReader(
|
|
|
|
|
`${missing.length} photo(s) n'ont pas pu être ajoutées à cette partie.\n` +
|
|
|
|
|
`Retélécharge cette partie depuis la galerie admin.\n\n${missing.join("\n")}\n`
|
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
await zipWriter.close();
|
|
|
|
|
} catch (err) {
|
|
|
|
|
// Écriture du ZIP elle-même en échec (client parti, le plus souvent) :
|
|
|
|
|
// pas de close() qui livrerait un ZIP tronqué d'apparence complète.
|
|
|
|
|
console.error("[admin-gallery] zip: stream build failed", err);
|
|
|
|
|
streamController.error(err);
|
|
|
|
|
}
|
|
|
|
|
})();
|
|
|
|
|
|
|
|
|
|
const zipFilename = `${sanitizeFilenamePart(slug || event.nom, "export")}.zip`;
|
|
|
|
|
const baseName = sanitizeFilenamePart(slug || event.nom, "export");
|
|
|
|
|
const zipFilename =
|
|
|
|
|
starts.length === 1 ? `${baseName}.zip` : `${baseName}-partie-${part}-sur-${starts.length}.zip`;
|
|
|
|
|
|
|
|
|
|
return new Response(readable, {
|
|
|
|
|
status: 200,
|
|
|
|
@@ -381,3 +465,92 @@ async function handleZipExport(
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Lit une photo en entier, 1 nouvel essai si Storage échoue. null = échec
|
|
|
|
|
// (journalisé), à l'appelant de la déclarer manquante.
|
|
|
|
|
async function fetchPhotoBytes(signedUrl: string): Promise<Uint8Array | null> {
|
|
|
|
|
for (let attempt = 1; attempt <= 2; attempt++) {
|
|
|
|
|
try {
|
|
|
|
|
const res = await fetch(signedUrl);
|
|
|
|
|
if (res.ok) return new Uint8Array(await res.arrayBuffer());
|
|
|
|
|
console.warn(`[admin-gallery] zip: storage HTTP ${res.status} (essai ${attempt})`);
|
|
|
|
|
await res.body?.cancel();
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.warn(`[admin-gallery] zip: storage fetch failed (essai ${attempt})`, err);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Réponses d'erreur du ZIP en texte lisible : la partie est ouverte par un
|
|
|
|
|
// lien direct (pas un fetch), c'est donc ce texte que l'organisateur voit.
|
|
|
|
|
function textResponse(status: number, message: string): Response {
|
|
|
|
|
return new Response(message, {
|
|
|
|
|
status,
|
|
|
|
|
headers: { ...corsHeaders(), "Content-Type": "text/plain; charset=utf-8" },
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// B1 : suppression d'une photo (original + miniature). Ordre : fichiers
|
|
|
|
|
// Storage PUIS ligne DB.
|
|
|
|
|
// - Storage échoue -> rien n'a bougé, 500, l'admin réessaie.
|
|
|
|
|
// - Ligne échoue après le fichier -> photo listée mais sans image (vignette
|
|
|
|
|
// cassée, absente du ZIP) ; réessayer termine le travail (remove() d'un
|
|
|
|
|
// fichier déjà absent ne renvoie pas d'erreur). L'ordre inverse laisserait
|
|
|
|
|
// un fichier invisible mais toujours présent : pire pour le droit à
|
|
|
|
|
// l'effacement, et seul le cas à éviter absolument ici.
|
|
|
|
|
async function handleDeletePhoto(
|
|
|
|
|
// deno-lint-ignore no-explicit-any
|
|
|
|
|
supabaseAdmin: any,
|
|
|
|
|
bucket: string,
|
|
|
|
|
event: AdminEventRow,
|
|
|
|
|
photoId: string | null
|
|
|
|
|
): Promise<Response> {
|
|
|
|
|
if (!photoId || !UUID_RE.test(photoId)) {
|
|
|
|
|
return jsonResponse(400, { error: "invalid_photo_id" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let photos: PhotoRow[];
|
|
|
|
|
try {
|
|
|
|
|
photos = await fetchEventPhotos(supabaseAdmin, event.id);
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.error("[admin-gallery] delete: get_event_photos_admin failed", err);
|
|
|
|
|
return jsonResponse(500, { error: "internal_error" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Appartenance à l'event du token : une photo d'un autre event est
|
|
|
|
|
// indiscernable d'une photo inexistante.
|
|
|
|
|
const photo = photos.find((p) => p.id === photoId.toLowerCase());
|
|
|
|
|
if (!photo) {
|
|
|
|
|
return jsonResponse(404, { error: "photo_not_found" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const { error: removeError } = await supabaseAdmin.storage
|
|
|
|
|
.from(bucket)
|
|
|
|
|
.remove([photo.url_storage, thumbPathOf(photo.url_storage)]);
|
|
|
|
|
if (removeError) {
|
|
|
|
|
console.error("[admin-gallery] delete: storage remove failed", removeError);
|
|
|
|
|
return jsonResponse(500, { error: "storage_delete_failed" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const { data: deleted, error: deleteError } = await supabaseAdmin.rpc(
|
|
|
|
|
"delete_event_photo",
|
|
|
|
|
{ p_event_id: event.id, p_photo_id: photo.id }
|
|
|
|
|
);
|
|
|
|
|
if (deleteError) {
|
|
|
|
|
console.error("[admin-gallery] delete: delete_event_photo failed", deleteError);
|
|
|
|
|
return jsonResponse(500, { error: "db_delete_failed" });
|
|
|
|
|
}
|
|
|
|
|
if (deleted !== true) {
|
|
|
|
|
// Supprimée entre-temps (double clic, autre onglet) : le résultat voulu
|
|
|
|
|
// est atteint, mais on le signale tel quel.
|
|
|
|
|
return jsonResponse(404, { error: "photo_not_found" });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const remaining = photos.filter((p) => p.id !== photo.id);
|
|
|
|
|
return jsonResponse(200, {
|
|
|
|
|
deleted: true,
|
|
|
|
|
photo_count: remaining.length,
|
|
|
|
|
zip_parts: zipPartStarts(remaining).length,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|