nodebb-plugin-onekite-calendar 2.0.11 → 2.0.13

package/pkg/package/CHANGELOG.md

@@ -0,0 +1,106 @@
+# Changelog – calendar-onekite
+
+## 1.3.6
+- ACP Comptabilisation : ajout d’un tableau séparé « Détails des sorties gratuites » (avec le nom du matériel).
+- Mobile FAB : la modale utilise maintenant des champs date avec calendrier (type="date") et empêche toute réservation pour le jour même ou dans le passé.
+
+## 1.3.5
+- ACP : ajout d’un paramètre « Location longue durée (jours) pour validateurs ». Si une réservation faite par un validateur dépasse ce nombre de jours, elle redevient payante et suit le workflow normal (demande → validation → paiement HelloAsso). Mets 0 pour conserver le comportement « toujours gratuit ».
+
+## 1.3.4
+- Réservations gratuites (validateurs) : ne sont plus comptées comme chiffre d’affaires dans la comptabilisation. Elles apparaissent désormais sur une ligne séparée « Sorties gratuites » (et sont marquées (gratuit) dans le détail).
+
+## 1.3.3
+- Comptabilité : les réservations « auto-checkées » (réservations faites par un validateur) recalculent désormais le total côté serveur (catalogue HelloAsso × nb jours calendaires) afin d’être comptabilisées correctement.
+
+## 1.3.2
+- Les membres validateurs (ceux qui peuvent valider/supprimer une demande) voient leurs propres réservations passer directement en statut payé/checked (pas de workflow paiement).
+- UI : message de succès adapté (réservation confirmée).
+
+## 1.3.1
+- ACP : ajout de 2 actions rapides dans l’onglet Maintenance : « Tout mettre en maintenance » et « Tout enlever de maintenance » (avec audit).
+
+## 1.3.0
+- Maintenance (sans dates) : blocage manuel ON/OFF par matériel (ACP + API). Les matériels en maintenance sont grisés et affichés comme : 🔧 Nom (en maintenance).
+- Audit : journal des actions (demande, validation, refus, annulation, maintenance) avec consultation et purge par année (ACP + API).
+
+## 1.2.18
+- API events + anti double booking : les tests de chevauchement utilisent désormais en priorité startDate/endDate (YYYY-MM-DD) quand disponibles (logique calendaire pure, endDate exclusive). Cela supprime définitivement les faux chevauchements liés aux timestamps/fuseaux/DST, notamment sur mobile et « Durée rapide ».
+
+## 1.2.17
+- Modale réservation : la requête de disponibilité initiale utilise aussi des dates calendaires (YYYY-MM-DD) au lieu de startStr/endStr/toISOString(), ce qui corrige le grisé erroné (mobile + durée rapide).
+
+## 1.2.16
+- Modale réservation (Durée rapide) : correction du grisé erroné des matériels réservés la veille. Les requêtes de disponibilité utilisent désormais des dates calendaires (YYYY-MM-DD) au lieu de toISOString() (UTC), pour éviter tout faux chevauchement lié au fuseau/DST.
+
+## 1.2.15
+- Réservations (Durée rapide) : génération des évènements all-day basée sur startDate/endDate (YYYY-MM-DD) quand disponibles, pour éviter tout décalage lié à toISOString() (UTC) et empêcher un grisé « non disponible » le jour suivant.
+
+## 1.2.14
+- Réservations : correction d’un faux chevauchement (problème 1h) quand FullCalendar envoie des bornes all-day à minuit UTC (Z / +00:00) — le lendemain n’est plus marqué « non disponible ».
+
+## 1.2.13
+- ACP (mode sombre) : correction de la visibilité de la liste d’autocomplete d’adresse (couleurs via variables Bootstrap)
+
+## 1.2.12
+- Modales (calendrier + ACP) : autocomplete adresse rendu identique et compatible Bootstrap input-group (plus de wrapper qui casse l’affichage)
+
+## 1.2.11
+- ACP : ajout de la recherche automatique d’adresse (autocomplete Nominatim) dans la modale de validation (unitaire + batch), comme sur le calendrier
+
+## 1.2.10
+- HelloAsso : calcul des jours 100% fiable (différence en jours calendaires Y/M/J, sans dépendance aux heures/au fuseau/DST)
+- FullCalendar : endDate traitée comme exclusive partout (UI + checkout)
+- HelloAsso : montant du checkout recalculé côté serveur à partir du catalogue (prix/jour × nbJours)
+
+## 1.2.9
+- Modale réservation : retour du grisé des matériels indisponibles (API events expose à nouveau itemIds)
+
+## 1.2.8
+- Popup réservation : correction « Durée rapide » (la période envoyée correspond bien à la durée sélectionnée)
+
+## 1.2.7
+- UI : suppression du bouton flottant mobile « + Réserver »
+- Client : nettoyage du code associé (suppression du bloc FAB)
+
+## 1.2.6
+- ACP : anti double action (verrou UI + boutons désactivés/spinner) sur valider/refuser (unitaire + batch)
+
+## 1.2.5
+- Mobile : bouton flottant « + Réserver »
+- Création : anti double-tap/click (verrou actions) + invalidation cache events + refetch léger
+- Calendrier : jours passés / aujourd’hui affichés comme non-sélectionnables (règle visuelle)
+- Popup réservation : raccourcis de durée (1j/2j/3j/7j) + recalcul total + mise à jour des matériels bloqués
+- ACP : actions en batch (valider/refuser une sélection) + compteur de sélection
+- API : idempotence sur valider/refuser + audit enrichi (refusedBy, cancelledByUsername)
+
+## 1.0.3
+- Suppression du texte d’archivage dans le toast de purge (plus de « 0 archivés »)
+- Renommage du plugin : nodebb-plugin-onekite-calendar
+- Discord : notification « ❌ Réservation annulée » (annulation manuelle + annulation automatique) + option ACP
+
+## 1.0.2
+- Purge calendrier : suppression réelle des réservations (aucune logique d’archivage)
+- Compta conservée séparément (la purge n’y touche jamais)
+
+## 1.0.1
+- ACP : modales Valider / Refuser OK (plus de retour au premier onglet)
+- Scheduler : optimisation (batch DB, scans réduits)
+- API events : pagination interne + ETag optimisé
+- HelloAsso : token mis en cache + protection rate-limit (429 / Cloudflare 1015), sans logs supplémentaires
+- Discord : notifications en embeds + icônes ⏳ (demande) et 💳 (paiement)
+- Widget : suppression de “2 semaines” dans le titre affiché
+- Correctifs divers de stabilité/performance (dont crash au démarrage)
+
+## 1.0.0
+- Première version stable du plugin calendar-onekite
+- Gestion des réservations de matériel avec contrôle de disponibilité
+- Calendrier FullCalendar via CDN
+- Validation / refus des demandes depuis l’ACP
+- Notifications Discord
+- Intégration paiements HelloAsso
+
+## 1.2.19
+- Mobile: ajout d’un bouton flottant (FAB) sur la page calendrier uniquement.
+- Le FAB ouvre une mini-modale de sélection de dates (dd/mm/yyyy) puis ouvre la modale standard de réservation.
+- Le FAB est automatiquement retiré quand on navigue hors de la page calendrier.

package/pkg/package/lib/admin.js

@@ -0,0 +1,554 @@
+'use strict';
+
+const meta = require.main.require('./src/meta');
+const user = require.main.require('./src/user');
+const emailer = require.main.require('./src/emailer');
+const nconf = require.main.require('nconf');
+
+function forumBaseUrl() {
+  const base = String(nconf.get('url') || '').trim().replace(/\/$/, '');
+  return base;
+}
+
+function formatFR(tsOrIso) {
+  const d = new Date(typeof tsOrIso === 'string' && /^[0-9]+$/.test(tsOrIso) ? parseInt(tsOrIso, 10) : tsOrIso);
+  const dd = String(d.getDate()).padStart(2, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const yyyy = d.getFullYear();
+  return `${dd}/${mm}/${yyyy}`;
+}
+
+function buildHelloAssoItemName(baseLabel, itemNames, start, end) {
+  const base = String(baseLabel || 'Réservation matériel Onekite').trim();
+  const items = Array.isArray(itemNames) ? itemNames.map((s) => String(s || '').trim()).filter(Boolean) : [];
+  const range = (start && end) ? `Du ${formatFR(start)} au ${formatFR(end)}` : '';
+  const lines = [base];
+  items.forEach((it) => lines.push(`• ${it}`));
+  if (range) lines.push(range);
+  let out = lines.join('\n').trim();
+  if (out.length > 250) {
+    out = out.slice(0, 249).trimEnd() + '…';
+  }
+  return out;
+}
+
+async function sendEmail(template, uid, subject, data) {
+  const toUid = Number.isInteger(uid) ? uid : (uid ? parseInt(uid, 10) : NaN);
+  if (!Number.isInteger(toUid) || toUid <= 0) return;
+
+  const params = Object.assign({}, data || {}, subject ? { subject } : {});
+
+  try {
+    if (typeof emailer.send !== 'function') return;
+    // NodeBB 4.x: send(template, uid, params)
+    // Do NOT branch on function.length (unreliable once wrapped/bound).
+    await emailer.send(template, toUid, params);
+  } catch (err) {
+    console.warn('[calendar-onekite] Failed to send email', {
+      template,
+      uid: toUid,
+      err: err && err.message ? err.message : String(err),
+    });
+  }
+}
+
+function normalizeCallbackUrl(configured, meta) {
+  const base = (meta && meta.config && (meta.config.url || meta.config['url'])) ? (meta.config.url || meta.config['url']) : '';
+  let url = (configured || '').trim();
+  if (!url) {
+    url = base ? `${base}/helloasso` : '';
+  }
+  if (url && url.startsWith('/') && base) {
+    url = `${base}${url}`;
+  }
+  return url;
+}
+
+function normalizeReturnUrl(meta) {
+  const base = (meta && meta.config && (meta.config.url || meta.config['url'])) ? (meta.config.url || meta.config['url']) : '';
+  const b = String(base || '').trim().replace(/\/$/, '');
+  if (!b) return '';
+  return `${b}/calendar`;
+}
+
+
+const dbLayer = require('./db');
+const helloasso = require('./helloasso');
+
+const ADMIN_PRIV = 'admin:settings';
+
+const admin = {};
+
+admin.renderAdmin = async function (req, res) {
+  res.render('admin/plugins/calendar-onekite', {
+    title: 'Calendar Onekite',
+  });
+};
+
+admin.getSettings = async function (req, res) {
+  const settings = await meta.settings.get('calendar-onekite');
+  res.json(settings || {});
+};
+
+admin.saveSettings = async function (req, res) {
+  await meta.settings.set('calendar-onekite', req.body || {});
+  res.json({ ok: true });
+};
+
+admin.listPending = async function (req, res) {
+  const ids = await dbLayer.listAllReservationIds(5000);
+  // Batch fetch to avoid N DB round-trips.
+  const rows = await dbLayer.getReservations(ids);
+  const pending = (rows || []).filter(r => r && r.status === 'pending');
+  pending.sort((a, b) => parseInt(a.start, 10) - parseInt(b.start, 10));
+  res.json(pending);
+};
+
+admin.approveReservation = async function (req, res) {
+  const rid = req.params.rid;
+  const r = await dbLayer.getReservation(rid);
+  if (!r) return res.status(404).json({ error: 'not-found' });
+
+  r.status = 'awaiting_payment';
+  r.pickupAddress = String((req.body && (req.body.pickupAddress || req.body.adminNote || req.body.note)) || '').trim();
+  r.notes = String((req.body && req.body.notes) || '').trim();
+  r.pickupTime = String((req.body && (req.body.pickupTime || req.body.pickup)) || '').trim();
+  r.pickupLat = String((req.body && req.body.pickupLat) || '').trim();
+  r.pickupLon = String((req.body && req.body.pickupLon) || '').trim();
+  r.approvedAt = Date.now();
+
+  try {
+    const approver = await user.getUserFields(req.uid, ['username']);
+    r.approvedBy = req.uid;
+    r.approvedByUsername = approver && approver.username ? approver.username : '';
+  } catch (e) {
+    r.approvedBy = req.uid;
+    r.approvedByUsername = '';
+  }
+
+  // Create HelloAsso payment link if configured
+  const settings = await meta.settings.get('calendar-onekite');
+  const env = settings.helloassoEnv || 'prod';
+  const token = await helloasso.getAccessToken({
+    env,
+    clientId: settings.helloassoClientId,
+    clientSecret: settings.helloassoClientSecret,
+  });
+        if (!token) {
+
+        }
+
+  let paymentUrl = null;
+  if (token) {
+    const requester = await user.getUserFields(r.uid, ['username', 'email']);
+    // r.total is stored as an estimated total in euros; HelloAsso expects cents.
+    const totalAmount = Math.max(0, Math.round((Number(r.total) || 0) * 100));
+    const base = forumBaseUrl();
+    const returnUrl = base ? `${base}/calendar` : '';
+    const webhookUrl = base ? `${base}/plugins/calendar-onekite/helloasso` : '';
+    const year = new Date(Number(r.start)).getFullYear();
+    const intent = await helloasso.createCheckoutIntent({
+      env,
+      token,
+      organizationSlug: settings.helloassoOrganizationSlug,
+      formType: settings.helloassoFormType,
+      // Form slug is derived from the year
+      formSlug: `locations-materiel-${year}`,
+      totalAmount,
+      payerEmail: requester && requester.email,
+      // User return/back/error URLs must be real pages; webhook uses the plugin endpoint.
+      callbackUrl: returnUrl,
+      webhookUrl: webhookUrl,
+      itemName: buildHelloAssoItemName('Réservation matériel Onekite', r.itemNames || (r.itemName ? [r.itemName] : []), r.start, r.end),
+      containsDonation: false,
+      metadata: {
+        reservationId: String(rid),
+        items: (Array.isArray(r.itemNames) ? r.itemNames : (r.itemName ? [r.itemName] : [])).filter(Boolean),
+        dateRange: `Du ${formatFR(r.start)} au ${formatFR(r.end)}`,
+      },
+    });
+    paymentUrl = intent && (intent.paymentUrl || intent.redirectUrl)
+      ? (intent.paymentUrl || intent.redirectUrl)
+      : (typeof intent === 'string' ? intent : null);
+    if (intent && intent.checkoutIntentId) {
+      r.checkoutIntentId = intent.checkoutIntentId;
+    }
+    }
+
+  if (paymentUrl) {
+    r.paymentUrl = paymentUrl;
+  } else {
+    console.warn('[calendar-onekite] HelloAsso payment link not created (approve ACP)', { rid });
+  }
+
+  await dbLayer.saveReservation(r);
+
+  // Email requester
+  try {
+    const requesterUid = parseInt(r.uid, 10);
+    const requester = await user.getUserFields(requesterUid, ['username']);
+    if (requesterUid) {
+      const latNum = Number(r.pickupLat);
+      const lonNum = Number(r.pickupLon);
+      const mapUrl = (Number.isFinite(latNum) && Number.isFinite(lonNum))
+        ? `https://www.openstreetmap.org/?mlat=${encodeURIComponent(String(latNum))}&mlon=${encodeURIComponent(String(lonNum))}#map=18/${encodeURIComponent(String(latNum))}/${encodeURIComponent(String(lonNum))}`
+        : '';
+      await sendEmail('calendar-onekite_approved', requesterUid, 'Location matériel - Réservation validée', {
+        uid: requesterUid,
+        username: requester && requester.username ? requester.username : '',
+        itemName: (Array.isArray(r.itemNames) ? r.itemNames.join(', ') : (r.itemName || '')),
+        itemNames: (Array.isArray(r.itemNames) ? r.itemNames : (r.itemName ? [r.itemName] : [])),
+        dateRange: `Du ${formatFR(r.start)} au ${formatFR(r.end)}`,
+        paymentUrl: paymentUrl || '',
+        pickupAddress: r.pickupAddress || '',
+        notes: r.notes || '',
+        pickupTime: r.pickupTime || '',
+        pickupLat: r.pickupLat || '',
+        pickupLon: r.pickupLon || '',
+        mapUrl,
+        validatedBy: r.approvedByUsername || '',
+        validatedByUrl: (r.approvedByUsername ? `https://www.onekite.com/user/${encodeURIComponent(String(r.approvedByUsername))}` : ''),
+      });
+    }
+  } catch (e) {}
+
+  res.json({ ok: true, paymentUrl: paymentUrl || null });
+};
+
+admin.refuseReservation = async function (req, res) {
+  const rid = req.params.rid;
+  const r = await dbLayer.getReservation(rid);
+  if (!r) return res.status(404).json({ error: 'not-found' });
+
+  r.status = 'refused';
+  r.refusedAt = Date.now();
+  r.refusedReason = String((req.body && (req.body.reason || req.body.refusedReason || req.body.refuseReason)) || '').trim();
+  await dbLayer.saveReservation(r);
+
+  try {
+    const requesterUid = parseInt(r.uid, 10);
+    const requester = await user.getUserFields(requesterUid, ['username']);
+    if (requesterUid) {
+      await sendEmail('calendar-onekite_refused', requesterUid, 'Location matériel - Réservation refusée', {
+        uid: requesterUid,
+        username: requester && requester.username ? requester.username : '',
+        itemName: (Array.isArray(r.itemNames) ? r.itemNames.join(', ') : (r.itemName || '')),
+        itemNames: (Array.isArray(r.itemNames) ? r.itemNames : (r.itemName ? [r.itemName] : [])),
+        dateRange: `Du ${formatFR(r.start)} au ${formatFR(r.end)}`,
+        start: formatFR(r.start),
+        end: formatFR(r.end),
+        refusedReason: r.refusedReason || '',
+      });
+    }
+  } catch (e) {}
+
+  res.json({ ok: true });
+};
+
+admin.purgeByYear = async function (req, res) {
+  const year = (req.body && req.body.year ? String(req.body.year) : '').trim();
+  if (!/^\d{4}$/.test(year)) {
+    return res.status(400).json({ error: 'invalid-year' });
+  }
+  const y = parseInt(year, 10);
+  const startTs = new Date(Date.UTC(y, 0, 1)).getTime();
+  const endTs = new Date(Date.UTC(y + 1, 0, 1)).getTime() - 1;
+
+  const ids = await dbLayer.listReservationIdsByStartRange(startTs, endTs, 100000);
+  let removed = 0;
+  for (const rid of ids) {
+    const r = await dbLayer.getReservation(rid);
+    if (!r) continue;
+
+    await dbLayer.removeReservation(rid);
+    removed++;
+  }
+  res.json({ ok: true, removed });
+};
+
+admin.purgeSpecialEventsByYear = async function (req, res) {
+  const year = (req.body && req.body.year ? String(req.body.year) : '').trim();
+  if (!/^\d{4}$/.test(year)) {
+    return res.status(400).json({ error: 'invalid-year' });
+  }
+  const y = parseInt(year, 10);
+  const startTs = new Date(Date.UTC(y, 0, 1)).getTime();
+  const endTs = new Date(Date.UTC(y + 1, 0, 1)).getTime() - 1;
+
+  const ids = await dbLayer.listSpecialIdsByStartRange(startTs, endTs, 100000);
+  let count = 0;
+  for (const eid of ids) {
+    await dbLayer.removeSpecialEvent(eid);
+    count++;
+  }
+  return res.json({ ok: true, removed: count });
+};
+
+// Debug endpoint to validate HelloAsso connectivity and item loading
+
+
+admin.debugHelloAsso = async function (req, res) {
+  const settings = await meta.settings.get('calendar-onekite');
+  const env = (settings && settings.helloassoEnv) || 'prod';
+
+  // Never expose secrets in debug output
+  const safeSettings = {
+    helloassoEnv: env,
+    helloassoClientId: settings && settings.helloassoClientId ? String(settings.helloassoClientId) : '',
+    helloassoClientSecret: settings && settings.helloassoClientSecret ? '***' : '',
+    helloassoOrganizationSlug: settings && settings.helloassoOrganizationSlug ? String(settings.helloassoOrganizationSlug) : '',
+    helloassoFormType: settings && settings.helloassoFormType ? String(settings.helloassoFormType) : '',
+    helloassoFormSlug: settings && settings.helloassoFormSlug ? String(settings.helloassoFormSlug) : '',
+  };
+
+  const out = {
+    ok: true,
+    settings: safeSettings,
+    token: { ok: false },
+    // Catalog = what you actually want for a shop (available products/material)
+    catalog: { ok: false, count: 0, sample: [], keys: [] },
+    // Sold items = items present in orders (can be 0 if no sales yet)
+    soldItems: { ok: false, count: 0, sample: [] },
+  };
+
+  try {
+    const token = await helloasso.getAccessToken({
+      env,
+      clientId: settings.helloassoClientId,
+      clientSecret: settings.helloassoClientSecret,
+    });
+    if (!token) {
+      out.token = { ok: false, error: 'token-null' };
+      return res.json(out);
+    }
+    out.token = { ok: true };
+
+    // Catalog items (via /public)
+    try {
+      const y = new Date().getFullYear();
+      const { publicForm, items } = await helloasso.listCatalogItems({
+        env,
+        token,
+        organizationSlug: settings.helloassoOrganizationSlug,
+        formType: settings.helloassoFormType,
+        formSlug: `locations-materiel-${y}`,
+      });
+
+      const arr = Array.isArray(items) ? items : [];
+      out.catalog.ok = true;
+      out.catalog.count = arr.length;
+      out.catalog.keys = publicForm && typeof publicForm === 'object' ? Object.keys(publicForm) : [];
+      out.catalog.sample = arr.slice(0, 10).map((it) => ({
+        id: it.id,
+        name: it.name,
+        price: it.price ?? null,
+      }));
+    } catch (e) {
+      out.catalog = { ok: false, error: String(e && e.message ? e.message : e), count: 0, sample: [], keys: [] };
+    }
+
+    // Sold items
+    try {
+      const y2 = new Date().getFullYear();
+      const items = await helloasso.listItems({
+        env,
+        token,
+        organizationSlug: settings.helloassoOrganizationSlug,
+        formType: settings.helloassoFormType,
+        formSlug: `locations-materiel-${y2}`,
+      });
+      const arr = Array.isArray(items) ? items : [];
+      out.soldItems.ok = true;
+      out.soldItems.count = arr.length;
+      out.soldItems.sample = arr.slice(0, 10).map((it) => ({
+        id: it.id || it.itemId || it.reference || it.name,
+        name: it.name || it.label || it.itemName,
+        price: it.price || it.amount || it.unitPrice || null,
+      }));
+    } catch (e) {
+      out.soldItems = { ok: false, error: String(e && e.message ? e.message : e), count: 0, sample: [] };
+    }
+
+    return res.json(out);
+  } catch (e) {
+    out.ok = false;
+    out.token = { ok: false, error: String(e && e.message ? e.message : e) };
+    return res.json(out);
+  }
+};
+
+// Accounting endpoint: aggregates paid reservations so you can contabilize what was rented.
+// Query params:
+//   from=YYYY-MM-DD (inclusive, based on reservation.start)
+//   to=YYYY-MM-DD (exclusive, based on reservation.start)
+admin.getAccounting = async function (req, res) {
+  const qFrom = String((req.query && req.query.from) || '').trim();
+  const qTo = String((req.query && req.query.to) || '').trim();
+  const parseDay = (s) => {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return null;
+    const [y, m, d] = s.split('-').map((x) => parseInt(x, 10));
+    const dt = new Date(Date.UTC(y, m - 1, d));
+    const ts = dt.getTime();
+    return Number.isFinite(ts) ? ts : null;
+  };
+  const fromTs = parseDay(qFrom);
+  const toTs = parseDay(qTo);
+
+  // Default: last 12 months (UTC)
+  const now = new Date();
+  const defaultTo = Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1);
+  const defaultFrom = Date.UTC(now.getUTCFullYear() - 1, now.getUTCMonth() + 1, 1);
+  const minTs = fromTs ?? defaultFrom;
+  const maxTs = toTs ?? defaultTo;
+
+  const ids = await dbLayer.listAllReservationIds(100000);
+  const rows = [];
+  const byItem = new Map();
+  let freeCount = 0;
+
+  for (const rid of ids) {
+    const r = await dbLayer.getReservation(rid);
+    if (!r) continue;
+    if (String(r.status) !== 'paid') continue;
+    if (r.accPurgedAt) continue;
+    const start = parseInt(r.start, 10);
+    if (!Number.isFinite(start)) continue;
+    if (start < minTs || start >= maxTs) continue;
+
+    const itemNames = Array.isArray(r.itemNames) && r.itemNames.length
+      ? r.itemNames
+      : (r.itemName ? [r.itemName] : []);
+
+    const isFree = !!r.isFree;
+    const total = isFree ? 0 : (Number(r.total) || 0);
+    const startDate = formatFR(r.start);
+    const endDate = formatFR(r.end);
+
+    if (isFree) freeCount += 1;
+
+    rows.push({
+      rid: r.rid,
+      uid: r.uid,
+      username: r.username || '',
+      start: r.start,
+      end: r.end,
+      startDate,
+      endDate,
+      items: itemNames,
+      total,
+      paidAt: r.paidAt || '',
+      isFree,
+    });
+
+    // Only count paid (non-free) reservations into revenue by item.
+    if (!isFree) {
+      for (const name of itemNames) {
+        const key = String(name || '').trim();
+        if (!key) continue;
+        const cur = byItem.get(key) || { item: key, count: 0, total: 0 };
+        cur.count += 1;
+        cur.total += total;
+        byItem.set(key, cur);
+      }
+    }
+  }
+
+  const summary = Array.from(byItem.values()).sort((a, b) => b.count - a.count);
+  if (freeCount > 0) {
+    summary.push({ item: 'Sorties gratuites', count: freeCount, total: 0, isFree: true });
+  }
+  rows.sort((a, b) => parseInt(a.start, 10) - parseInt(b.start, 10));
+
+  return res.json({
+    ok: true,
+    from: new Date(minTs).toISOString().slice(0, 10),
+    to: new Date(maxTs).toISOString().slice(0, 10),
+    summary,
+    rows,
+  });
+};
+
+admin.exportAccountingCsv = async function (req, res) {
+  // Reuse the same logic and emit a CSV.
+  const fakeRes = { json: (x) => x };
+  const data = await admin.getAccounting(req, fakeRes);
+  // If getAccounting returned via res.json, data is undefined; rebuild by calling logic directly.
+  // Easiest: call getAccounting's internals by fetching the endpoint logic via HTTP is not possible here.
+  // So we re-run getAccounting but capture output by monkeypatching.
+  let payload;
+  await admin.getAccounting(req, { json: (x) => { payload = x; return x; } });
+  if (!payload || !payload.ok) {
+    return res.status(500).send('error');
+  }
+  const escape = (v) => {
+    const s = String(v ?? '');
+    if (/[\n\r,\"]/g.test(s)) {
+      return '"' + s.replace(/"/g, '""') + '"';
+    }
+    return s;
+  };
+  const lines = [];
+  lines.push(['rid', 'username', 'uid', 'start', 'end', 'items', 'total', 'paidAt', 'isFree'].map(escape).join(','));
+  for (const r of payload.rows || []) {
+    lines.push([
+      r.rid,
+      r.username,
+      r.uid,
+      r.startDate,
+      r.endDate,
+      (Array.isArray(r.items) ? r.items.join(' | ') : ''),
+      (Number(r.total) || 0).toFixed(2),
+      r.paidAt ? new Date(parseInt(r.paidAt, 10)).toISOString() : '',
+      r.isFree ? '1' : '0',
+    ].map(escape).join(','));
+  }
+  const csv = lines.join('\n');
+  res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+  res.setHeader('Content-Disposition', 'attachment; filename="calendar-onekite-accounting.csv"');
+  return res.send(csv);
+};
+
+
+admin.purgeAccounting = async function (req, res) {
+  const qFrom = String((req.query && req.query.from) || '').trim();
+  const qTo = String((req.query && req.query.to) || '').trim();
+  const parseDay = (s) => {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return null;
+    const [y, m, d] = s.split('-').map((x) => parseInt(x, 10));
+    const dt = new Date(Date.UTC(y, m - 1, d));
+    const ts = dt.getTime();
+    return Number.isFinite(ts) ? ts : null;
+  };
+  const fromTs = parseDay(qFrom);
+  const toTs = parseDay(qTo);
+
+  const now = new Date();
+  const defaultTo = Date.UTC(now.getUTCFullYear() + 100, 0, 1); // far future
+  const defaultFrom = Date.UTC(1970, 0, 1);
+  const minTs = fromTs ?? defaultFrom;
+  const maxTs = toTs ?? defaultTo;
+
+  const ids = await dbLayer.listAllReservationIds(200000);
+  let purged = 0;
+  const ts = Date.now();
+
+  for (const rid of ids) {
+    const r = await dbLayer.getReservation(rid);
+    if (!r) continue;
+    if (String(r.status) !== 'paid') continue;
+    // Already purged from accounting
+    if (r.accPurgedAt) continue;
+    const start = parseInt(r.start, 10);
+    if (!Number.isFinite(start)) continue;
+    if (start < minTs || start >= maxTs) continue;
+
+    r.accPurgedAt = ts;
+    await dbLayer.saveReservation(r);
+    purged++;
+  }
+
+  return res.json({ ok: true, purged });
+};
+
+
+module.exports = admin;