nodebb-plugin-calendar-onekite 11.1.76 → 11.1.78

package/lib/admin.js

@@ -21,28 +21,39 @@ function formatFR(tsOrIso) {
 async function sendEmail(template, toEmail, subject, data) {
   if (!toEmail) return;
   try {
-    // Some NodeBB emailer implementations only read subject from the data object,
-    // others accept it as an explicit argument. To maximize compatibility we set both.
     const dataWithSubject = Object.assign({}, data || {}, subject ? { subject, _subject: subject } : {});
+
+    // Same compatibility strategy as lib/api.js
+    const attempts = [];
     if (typeof emailer.sendToEmail === 'function') {
-      if (emailer.sendToEmail.length >= 4) {
-        await emailer.sendToEmail(template, toEmail, subject, dataWithSubject);
+      if (emailer.sendToEmail.length === 3) {
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
       } else {
-        await emailer.sendToEmail(template, toEmail, dataWithSubject);
+        attempts.push(() => emailer.sendToEmail(template, toEmail, subject, dataWithSubject));
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject, subject));
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
       }
-      return;
     }
     if (typeof emailer.send === 'function') {
-      if (emailer.send.length >= 4) {
-        await emailer.send(template, toEmail, subject, dataWithSubject);
-        return;
-      }
       if (emailer.send.length === 3) {
-        await emailer.send(template, toEmail, dataWithSubject);
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+      } else {
+        attempts.push(() => emailer.send(template, toEmail, subject, dataWithSubject));
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject, subject));
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+      }
+    }
+
+    let lastErr = null;
+    for (const fn of attempts) {
+      try {
+        await fn();
         return;
+      } catch (e) {
+        lastErr = e;
       }
-      await emailer.send(template, toEmail, subject, dataWithSubject);
     }
+    if (lastErr) throw lastErr;
   } catch (err) {
     console.warn('[calendar-onekite] Failed to send email', { template, toEmail, err: String(err && err.message || err) });
   }

package/lib/api.js

@@ -15,27 +15,43 @@ const helloasso = require('./helloasso');
 async function sendEmail(template, toEmail, subject, data) {
   if (!toEmail) return;
   const emailer = require.main.require('./src/emailer');
-  const dataWithSubject = Object.assign({}, data || {}, subject ? { subject } : {});
+  const dataWithSubject = Object.assign({}, data || {}, subject ? { subject, _subject: subject } : {});
   try {
-    // NodeBB's Emailer API differs across versions; the most reliable approach is to pass `subject` inside `data`.
+    // NodeBB Emailer signatures vary across versions/plugins.
+    // IMPORTANT: some implementations accept (template, email, data) and will NOT throw if we pass a string as `data`,
+    // which can lead to "sent but empty subject". So we prefer the (template, email, data) call first when arity hints it.
+    const attempts = [];
+
     if (typeof emailer.sendToEmail === 'function') {
-      // Prefer 3-args (template, email, data) when possible
-      if (emailer.sendToEmail.length >= 3) {
-        await emailer.sendToEmail(template, toEmail, dataWithSubject);
-        return;
+      if (emailer.sendToEmail.length === 3) {
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
+      } else {
+        // Try the common forms that include subject
+        attempts.push(() => emailer.sendToEmail(template, toEmail, subject, dataWithSubject));
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject, subject));
+        attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
       }
-      // Fallback
-      await emailer.sendToEmail(template, toEmail, subject, data);
-      return;
     }
     if (typeof emailer.send === 'function') {
-      if (emailer.send.length >= 3) {
-        await emailer.send(template, toEmail, dataWithSubject);
+      if (emailer.send.length === 3) {
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+      } else {
+        attempts.push(() => emailer.send(template, toEmail, subject, dataWithSubject));
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject, subject));
+        attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+      }
+    }
+
+    let lastErr = null;
+    for (const fn of attempts) {
+      try {
+        await fn();
         return;
+      } catch (e) {
+        lastErr = e;
       }
-      await emailer.send(template, toEmail, subject, data);
-      return;
     }
+    if (lastErr) throw lastErr;
   } catch (err) {
     // eslint-disable-next-line no-console
     console.warn('[calendar-onekite] Failed to send email', { template, toEmail, err: String((err && err.message) || err) });

package/lib/scheduler.js

@@ -58,21 +58,38 @@ async function processAwaitingPayment() {
   async function sendEmail(template, toEmail, subject, data) {
     if (!toEmail) return;
     try {
+      const dataWithSubject = Object.assign({}, data || {}, subject ? { subject, _subject: subject } : {});
+
+      const attempts = [];
       if (typeof emailer.sendToEmail === 'function') {
-        await emailer.sendToEmail(template, toEmail, subject, data);
-        return;
+        if (emailer.sendToEmail.length === 3) {
+          attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
+        } else {
+          attempts.push(() => emailer.sendToEmail(template, toEmail, subject, dataWithSubject));
+          attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject, subject));
+          attempts.push(() => emailer.sendToEmail(template, toEmail, dataWithSubject));
+        }
       }
       if (typeof emailer.send === 'function') {
-        if (emailer.send.length >= 4) {
-          await emailer.send(template, toEmail, subject, data);
-          return;
-        }
         if (emailer.send.length === 3) {
-          await emailer.send(template, toEmail, data);
+          attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+        } else {
+          attempts.push(() => emailer.send(template, toEmail, subject, dataWithSubject));
+          attempts.push(() => emailer.send(template, toEmail, dataWithSubject, subject));
+          attempts.push(() => emailer.send(template, toEmail, dataWithSubject));
+        }
+      }
+
+      let lastErr = null;
+      for (const fn of attempts) {
+        try {
+          await fn();
           return;
+        } catch (e) {
+          lastErr = e;
         }
-        await emailer.send(template, toEmail, subject, data);
       }
+      if (lastErr) throw lastErr;
     } catch (err) {
       // eslint-disable-next-line no-console
       console.warn('[calendar-onekite] Failed to send email (scheduler)', { template, toEmail, err: String(err && err.message || err) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-calendar-onekite",
-  "version": "11.1.76",
+  "version": "11.1.78",
   "description": "FullCalendar-based equipment reservation workflow with admin approval & HelloAsso payment for NodeBB",
   "main": "library.js",
   "license": "MIT",

package/plugin.json

@@ -27,15 +27,11 @@
     "public": "./public"
   },
   "templates": "./templates",
-  "modules": {
-    "../admin/plugins/calendar-onekite.js": "./public/admin.js",
-    "admin/plugins/calendar-onekite": "./public/admin.js"
-  },
   "scripts": [
     "public/client.js"
   ],
   "acpScripts": [
     "public/admin.js"
   ],
-  "version": "1.0.53"
-}
+  "version": "1.0.55"
+}

package/public/admin.amd.js

@@ -0,0 +1,761 @@
+
+define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts, bootbox) {
+  'use strict';
+
+  function showAlert(type, msg) {
+    try {
+      if (alerts && typeof alerts[type] === 'function') {
+        alerts[type](msg);
+        return;
+      }
+    } catch (e) {}
+    alert(msg);
+  }
+
+  async function fetchJson(url, opts) {
+    const res = await fetch(url, {
+      credentials: 'same-origin',
+      headers: (() => {
+        const headers = { 'Content-Type': 'application/json' };
+        const token =
+          (window.config && (window.config.csrf_token || window.config.csrfToken)) ||
+          (window.ajaxify && window.ajaxify.data && window.ajaxify.data.csrf_token) ||
+          (document.querySelector('meta[name="csrf-token"]') && document.querySelector('meta[name="csrf-token"]').getAttribute('content')) ||
+          (document.querySelector('meta[name="csrf_token"]') && document.querySelector('meta[name="csrf_token"]').getAttribute('content')) ||
+          (typeof app !== 'undefined' && app && app.csrfToken) ||
+          null;
+        if (token) headers['x-csrf-token'] = token;
+        return headers;
+      })(),
+      ...opts,
+    });
+
+
+    if (!res.ok) {
+      // NodeBB versions differ: some expose admin APIs under /api/admin instead of /api/v3/admin
+      if (res.status === 404 && typeof url === 'string' && url.includes('/api/v3/admin/')) {
+        const altUrl = url.replace('/api/v3/admin/', '/api/admin/');
+        const res2 = await fetch(altUrl, {
+          credentials: 'same-origin',
+          headers: (() => {
+            const headers = { 'Content-Type': 'application/json' };
+            const token =
+              (window.config && (window.config.csrf_token || window.config.csrfToken)) ||
+              (window.ajaxify && window.ajaxify.data && window.ajaxify.data.csrf_token) ||
+              (document.querySelector('meta[name="csrf-token"]') && document.querySelector('meta[name="csrf-token"]').getAttribute('content')) ||
+              (document.querySelector('meta[name="csrf_token"]') && document.querySelector('meta[name="csrf_token"]').getAttribute('content')) ||
+              (typeof app !== 'undefined' && app && app.csrfToken) ||
+              null;
+            if (token) headers['x-csrf-token'] = token;
+            return headers;
+          })(),
+          ...opts,
+        });
+        if (res2.ok) {
+          return await res2.json();
+        }
+      }
+      const text = await res.text().catch(() => '');
+      throw new Error(`${res.status} ${text}`);
+    }
+    return await res.json();
+  }
+
+  // Leaflet (OpenStreetMap) helpers - loaded lazily only when needed.
+  let leafletPromise = null;
+  function loadLeaflet() {
+    if (leafletPromise) return leafletPromise;
+    leafletPromise = new Promise((resolve, reject) => {
+      try {
+        if (window.L && window.L.map) {
+          resolve(window.L);
+          return;
+        }
+        const cssId = 'onekite-leaflet-css';
+        const jsId = 'onekite-leaflet-js';
+        if (!document.getElementById(cssId)) {
+          const link = document.createElement('link');
+          link.id = cssId;
+          link.rel = 'stylesheet';
+          link.href = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css';
+          document.head.appendChild(link);
+        }
+        const existing = document.getElementById(jsId);
+        if (existing) {
+          existing.addEventListener('load', () => resolve(window.L));
+          existing.addEventListener('error', () => reject(new Error('leaflet-load-failed')));
+          return;
+        }
+        const script = document.createElement('script');
+        script.id = jsId;
+        script.async = true;
+        script.src = 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js';
+        script.onload = () => resolve(window.L);
+        script.onerror = () => reject(new Error('leaflet-load-failed'));
+        document.head.appendChild(script);
+      } catch (e) {
+        reject(e);
+      }
+    });
+    return leafletPromise;
+  }
+
+  async function geocodeAddress(query) {
+    const q = String(query || '').trim();
+    if (!q) return null;
+    const url = `https://nominatim.openstreetmap.org/search?format=jsonv2&limit=1&q=${encodeURIComponent(q)}`;
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Accept-Language': 'fr',
+      },
+    });
+    if (!res.ok) return null;
+    const arr = await res.json();
+    if (!Array.isArray(arr) || !arr.length) return null;
+    const hit = arr[0];
+    const lat = Number(hit.lat);
+    const lon = Number(hit.lon);
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+    return { lat, lon, displayName: hit.display_name || q };
+  }
+
+  function formToObject(form) {
+    const out = {};
+    new FormData(form).forEach((v, k) => {
+      out[k] = String(v);
+    });
+    return out;
+  }
+
+  function fillForm(form, data) {
+    [...form.elements].forEach((el) => {
+      if (!el.name) return;
+      if (Object.prototype.hasOwnProperty.call(data, el.name)) {
+        el.value = data[el.name];
+      }
+    });
+  }
+
+  function normalizeCsvGroupsWithDefault(csv, defaultGroup) {
+    const extras = String(csv || '').split(',').map(s => s.trim()).filter(Boolean);
+    const set = new Set();
+    const out = [];
+    if (defaultGroup) {
+      const dg = String(defaultGroup).trim();
+      if (dg) {
+        set.add(dg);
+        out.push(dg);
+      }
+    }
+    for (const g of extras) {
+      if (!set.has(g)) {
+        set.add(g);
+        out.push(g);
+      }
+    }
+    return out.join(', ');
+  }
+
+  function ensureSpecialFieldsExist(form) {
+    // If the ACP template didn't include these fields (older installs), inject them.
+    if (!form) return;
+    const hasCreator = form.querySelector('[name="specialCreatorGroups"]');
+    const hasDeleter = form.querySelector('[name="specialDeleterGroups"]');
+    if (hasCreator && hasDeleter) return;
+    const wrap = document.createElement('div');
+    wrap.innerHTML = `
+      <hr />
+      <h4>Évènements (autre couleur)</h4>
+      <p class="text-muted" style="max-width: 900px;">Permet de créer des évènements non liés aux locations (autre couleur), avec date/heure, adresse (OpenStreetMap) et notes.</p>
+      <div class="mb-3">
+        <label class="form-label">Groupes autorisés à créer ces évènements (CSV)</label>
+        <input type="text" class="form-control" name="specialCreatorGroups" placeholder="ex: staff, instructors" />
+      </div>
+      <div class="mb-3">
+        <label class="form-label">Groupes autorisés à supprimer ces évènements (CSV)</label>
+        <input type="text" class="form-control" name="specialDeleterGroups" placeholder="ex: administrators" />
+      </div>
+    `;
+    form.appendChild(wrap);
+  }
+
+  
+  function renderPending(list) {
+    const wrap = document.getElementById('onekite-pending');
+    if (!wrap) return;
+    wrap.innerHTML = '';
+
+    if (!list || !list.length) {
+      wrap.innerHTML = '<div class="text-muted">Aucune demande.</div>';
+      return;
+    }
+
+    const fmtFR = (ts) => {
+      const d = new Date(parseInt(ts, 10));
+      const dd = String(d.getDate()).padStart(2, '0');
+      const mm = String(d.getMonth() + 1).padStart(2, '0');
+      const yyyy = d.getFullYear();
+      const hh = String(d.getHours()).padStart(2, '0');
+      const mi = String(d.getMinutes()).padStart(2, '0');
+      return `${dd}/${mm}/${yyyy} ${hh}:${mi}`;
+    };
+
+    for (const r of list) {
+      const created = r.createdAt ? fmtFR(r.createdAt) : '';
+      const itemNames = Array.isArray(r.itemNames) && r.itemNames.length ? r.itemNames : [r.itemName || r.itemId].filter(Boolean);
+      const itemsHtml = `<ul style="margin: 0 0 10px 18px;">${itemNames.map(n => `<li>${escapeHtml(String(n))}</li>`).join('')}</ul>`;
+      const div = document.createElement('div');
+      div.className = 'list-group-item';
+      div.innerHTML = `
+        <div class="d-flex justify-content-between align-items-start gap-2">
+          <div style="min-width: 0;">
+            <div><strong>${itemsHtml || escapeHtml(r.itemName || '')}</strong></div>
+            <div class="text-muted" style="font-size: 12px;">Créée: ${escapeHtml(created)}</div>
+            <div class="text-muted" style="font-size: 12px;">Période: ${escapeHtml(new Date(parseInt(r.start, 10)).toLocaleDateString('fr-FR'))} → ${escapeHtml(new Date(parseInt(r.end, 10)).toLocaleDateString('fr-FR'))}</div>
+          </div>
+          <div class="d-flex gap-2">
+            <button class="btn btn-outline-danger btn-sm">Rejeter</button>
+            <button class="btn btn-success btn-sm">Valider</button>
+          </div>
+        </div>
+      `;
+      const [refuseBtn, approveBtn] = div.querySelectorAll('button');
+      refuseBtn.addEventListener('click', async () => {
+        if (!confirm('Rejeter cette demande ?')) return;
+        try {
+          // Server route: PUT /api/v3/admin/plugins/calendar-onekite/reservations/:rid/refuse
+          await fetchJson(`/api/v3/admin/plugins/calendar-onekite/reservations/${encodeURIComponent(r.rid)}/refuse`, { method: 'PUT' });
+          showAlert('success', 'Demande rejetée.');
+          await loadPending();
+        } catch (e) {
+          showAlert('error', 'Rejet impossible.');
+        }
+      });
+
+      approveBtn.addEventListener('click', async () => {
+        const itemNamesModal = Array.isArray(r.itemNames) && r.itemNames.length ? r.itemNames : [r.itemName || r.itemId].filter(Boolean);
+        const itemsHtmlModal = `<ul style="margin: 0 0 10px 18px;">${itemNamesModal.map(n => `<li>${escapeHtml(String(n))}</li>`).join('')}</ul>`;
+
+        const opts = (() => {
+          const out = [];
+          for (let h = 7; h < 24; h++) {
+            for (let m = 0; m < 60; m += 5) {
+              out.push(`${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`);
+            }
+          }
+          return out;
+        })().map(t => `<option value="${t}">${t}</option>`).join('');
+
+        const html = `
+          <div class="mb-2"><strong>Matériel</strong>${itemsHtmlModal}</div>
+          <div class="mb-3">
+            <label class="form-label">Adresse de récupération</label>
+            <div class="input-group">
+              <input type="text" class="form-control" id="onekite-pickup-address" placeholder="Adresse complète" />
+              <button class="btn btn-outline-secondary" type="button" id="onekite-geocode">Rechercher</button>
+            </div>
+            <div id="onekite-map" style="height:220px; border:1px solid #ddd; border-radius:6px; margin-top:0.5rem;"></div>
+            <div class="form-text">Vous pouvez déplacer le marqueur pour ajuster la position.</div>
+            <input type="hidden" id="onekite-pickup-lat" />
+            <input type="hidden" id="onekite-pickup-lon" />
+          </div>
+          <div class="mb-3">
+            <label class="form-label">Notes (facultatif)</label>
+            <textarea class="form-control" id="onekite-notes" rows="3" placeholder="Ex: code portail, personne à contacter, horaires..."></textarea>
+          </div>
+          <div class="mb-2">
+            <label class="form-label">Heure de récupération</label>
+            <select class="form-select" id="onekite-pickup-time">${opts}</select>
+          </div>
+        `;
+
+        const dlg = bootbox.dialog({
+          title: 'Valider la demande',
+          message: html,
+          buttons: {
+            cancel: { label: 'Annuler', className: 'btn-secondary' },
+            ok: {
+              label: 'Valider',
+              className: 'btn-success',
+              callback: async () => {
+                try {
+                  const pickupAddress = (document.getElementById('onekite-pickup-address')?.value || '').trim();
+                  const notes = (document.getElementById('onekite-notes')?.value || '').trim();
+                  const pickupTime = (document.getElementById('onekite-pickup-time')?.value || '').trim();
+                  const pickupLat = (document.getElementById('onekite-pickup-lat')?.value || '').trim();
+                  const pickupLon = (document.getElementById('onekite-pickup-lon')?.value || '').trim();
+                  // Server route: PUT /api/v3/admin/plugins/calendar-onekite/reservations/:rid/approve
+                  await fetchJson(`/api/v3/admin/plugins/calendar-onekite/reservations/${encodeURIComponent(r.rid)}/approve`, { method: 'PUT', body: JSON.stringify({ pickupAddress, notes, pickupTime, pickupLat, pickupLon }) });
+                  showAlert('success', 'Demande validée.');
+                  await loadPending();
+                } catch (e) {
+                  showAlert('error', 'Validation impossible.');
+                }
+              },
+            },
+          },
+        });
+
+        dlg.on('shown.bs.modal', async () => {
+          try {
+            const L = await loadLeaflet();
+            const mapEl = document.getElementById('onekite-map');
+            if (!mapEl) return;
+            const map = L.map(mapEl, { scrollWheelZoom: false });
+            L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+              maxZoom: 19,
+              attribution: '&copy; OpenStreetMap',
+            }).addTo(map);
+            map.setView([46.7, 2.5], 5);
+            let marker = null;
+            function setMarker(lat, lon, zoom) {
+              const ll = [lat, lon];
+              if (!marker) {
+                marker = L.marker(ll, { draggable: true }).addTo(map);
+                marker.on('dragend', () => {
+                  const p2 = marker.getLatLng();
+                  document.getElementById('onekite-pickup-lat').value = String(p2.lat);
+                  document.getElementById('onekite-pickup-lon').value = String(p2.lng);
+                });
+              } else {
+                marker.setLatLng(ll);
+              }
+              document.getElementById('onekite-pickup-lat').value = String(lat);
+              document.getElementById('onekite-pickup-lon').value = String(lon);
+              if (zoom) map.setView(ll, zoom); else map.panTo(ll);
+            }
+            map.on('click', (e) => {
+              if (e && e.latlng) setMarker(e.latlng.lat, e.latlng.lng, map.getZoom());
+            });
+            const geocodeBtn = document.getElementById('onekite-geocode');
+            const addrInput = document.getElementById('onekite-pickup-address');
+            async function runGeocode() {
+              try {
+                const addr = (addrInput?.value || '').trim();
+                if (!addr) return;
+                const hit = await geocodeAddress(addr);
+                if (!hit) {
+                  showAlert('error', 'Adresse introuvable.');
+                  return;
+                }
+                setMarker(hit.lat, hit.lon, 16);
+              } catch (e) {
+                showAlert('error', 'Recherche adresse impossible.');
+              }
+            }
+            if (geocodeBtn) geocodeBtn.addEventListener('click', runGeocode);
+            if (addrInput) {
+              addrInput.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter') {
+                  e.preventDefault();
+                  runGeocode();
+                }
+              });
+            }
+          } catch (e) {}
+        });
+        return false;
+      });
+
+      wrap.appendChild(div);
+    }
+  }
+
+
+  function timeOptions(stepMinutes) {
+    const step = stepMinutes || 5;
+    const out = [];
+    for (let h = 7; h < 24; h++) {
+      for (let m = 0; m < 60; m += step) {
+        const hh = String(h).padStart(2, '0');
+        const mm = String(m).padStart(2, '0');
+        out.push(`${hh}:${mm}`);
+      }
+    }
+    return out;
+  }
+
+  function escapeHtml(s) {
+    return String(s || '')
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+  }
+
+  async function loadSettings() {
+    return await fetchJson('/api/v3/admin/plugins/calendar-onekite/settings');
+  }
+
+  async function saveSettings(payload) {
+    return await fetchJson('/api/v3/admin/plugins/calendar-onekite/settings', {
+      method: 'PUT',
+      body: JSON.stringify(payload),
+    });
+  }
+
+  async function loadPending() {
+    return await fetchJson('/api/v3/admin/plugins/calendar-onekite/pending');
+  }
+
+  async function approve(rid, payload) {
+    return await fetchJson(`/api/v3/admin/plugins/calendar-onekite/reservations/${rid}/approve`, {
+      method: 'PUT',
+      body: JSON.stringify(payload || {}),
+    });
+  }
+
+  async function refuse(rid) {
+    return await fetchJson(`/api/v3/admin/plugins/calendar-onekite/reservations/${rid}/refuse`, { method: 'PUT' });
+  }
+
+  async function purge(year) {
+    return await fetchJson('/api/v3/admin/plugins/calendar-onekite/purge', {
+      method: 'POST',
+      body: JSON.stringify({ year }),
+    });
+  }
+
+  async function purgeSpecialEvents(year) {
+    try {
+      return await fetchJson('/api/v3/admin/plugins/calendar-onekite/special-events/purge', {
+        method: 'POST',
+        body: JSON.stringify({ year }),
+      });
+    } catch (e) {
+      return await fetchJson('/api/admin/plugins/calendar-onekite/special-events/purge', {
+        method: 'POST',
+        body: JSON.stringify({ year }),
+      });
+    }
+  }
+
+  async function debugHelloAsso() {
+    try {
+      return await fetchJson('/api/v3/admin/plugins/calendar-onekite/debug');
+    } catch (e) {
+      return await fetchJson('/api/admin/plugins/calendar-onekite/debug');
+    }
+  }
+
+  async function loadAccounting(from, to) {
+    const params = new URLSearchParams();
+    if (from) params.set('from', from);
+    if (to) params.set('to', to);
+    const qs = params.toString();
+    return await fetchJson(`/api/v3/admin/plugins/calendar-onekite/accounting${qs ? `?${qs}` : ''}`);
+  }
+
+  async function init() {
+    const form = document.getElementById('onekite-settings-form');
+    if (!form) return;
+
+    // Load settings
+    try {
+      const s = await loadSettings();
+      fillForm(form, s || {});
+
+      // Ensure default creator group prefix appears in the ACP field
+      const y = new Date().getFullYear();
+      const defaultGroup = `onekite-ffvl-${y}`;
+      const cgEl = form.querySelector('[name="creatorGroups"]');
+      if (cgEl) {
+        cgEl.value = normalizeCsvGroupsWithDefault(cgEl.value, defaultGroup);
+      }
+    } catch (e) {
+      showAlert('error', 'Impossible de charger les paramètres.');
+    }
+
+    // Load pending
+    async function refreshPending() {
+      try {
+        const p = await loadPending();
+        renderPending(p);
+      } catch (e) {
+        showAlert('error', 'Impossible de charger les demandes en attente.');
+      }
+    }
+
+    await refreshPending();
+
+    async function doSave(ev) {
+      // Guard against duplicate handlers (some themes bind multiple save buttons)
+      // and against rapid double-clicks.
+      if (doSave._inFlight) {
+        if (ev && typeof ev.preventDefault === 'function') ev.preventDefault();
+        return;
+      }
+      doSave._inFlight = true;
+      try {
+        if (ev && typeof ev.preventDefault === 'function') ev.preventDefault();
+        const payload = formToObject(form);
+        // Always prefix with default yearly group
+        const y = new Date().getFullYear();
+        const defaultGroup = `onekite-ffvl-${y}`;
+        if (Object.prototype.hasOwnProperty.call(payload, 'creatorGroups')) {
+          payload.creatorGroups = normalizeCsvGroupsWithDefault(payload.creatorGroups, defaultGroup);
+        }
+        await saveSettings(payload);
+        showAlert('success', 'Paramètres enregistrés.');
+      } catch (e) {
+        showAlert('error', 'Échec de l\'enregistrement.');
+      } finally {
+        doSave._inFlight = false;
+      }
+    }
+
+    // Save buttons (NodeBB header/footer "Enregistrer" + floppy icon)
+    // Use ONE delegated listener to avoid double submissions.
+    const SAVE_SELECTOR = '#save, .save, [data-action="save"], .settings-save, .floating-save, .btn[data-action="save"]';
+    document.addEventListener('click', (ev) => {
+      const btn = ev.target && ev.target.closest && ev.target.closest(SAVE_SELECTOR);
+      if (!btn) return;
+      // Only handle clicks while we're on this plugin page
+      if (!document.getElementById('onekite-settings-form')) return;
+      doSave(ev);
+    });
+
+    // Approve/refuse buttons
+    const pendingWrap = document.getElementById('onekite-pending');
+    if (pendingWrap) {
+      pendingWrap.addEventListener('click', async (ev) => {
+        const btn = ev.target && ev.target.closest('button[data-action]');
+        if (!btn) return;
+        const action = btn.getAttribute('data-action');
+        const rid = btn.getAttribute('data-rid');
+        if (!rid) return;
+
+        try {
+          if (action === 'approve') {
+            const opts = timeOptions(5).map(t => `<option value="${t}">${t}</option>`).join('');
+            const html = `
+              <div class="mb-3">
+                <label class="form-label">Note (incluse dans l'email)</label>
+                <textarea class="form-control" id="onekite-admin-note" rows="3" placeholder="Matériel à récupérer à l'adresse : ..."></textarea>
+              </div>
+              <div class="mb-2">
+                <label class="form-label">Heure de récupération</label>
+                <select class="form-select" id="onekite-pickup-time">${opts}</select>
+              </div>
+            `;
+            await new Promise((resolve) => {
+              bootbox.dialog({
+                title: 'Valider la réservation',
+                message: html,
+                buttons: {
+                  cancel: { label: 'Annuler', className: 'btn-secondary', callback: () => resolve(false) },
+                  ok: {
+                    label: 'Valider',
+                    className: 'btn-success',
+                    callback: async () => {
+                      try {
+                        const adminNote = (document.getElementById('onekite-admin-note')?.value || '').trim();
+                        const pickupTime = (document.getElementById('onekite-pickup-time')?.value || '').trim();
+                        await approve(rid, { adminNote, pickupTime });
+                        bootbox.alert('Réservation validée.');
+                        resolve(true);
+                      } catch (e) {
+                        showAlert('error', 'Validation impossible.');
+                        resolve(false);
+                      }
+                      return false;
+                    },
+                  },
+                },
+              });
+            });
+          } else if (action === 'refuse') {
+            await refuse(rid);
+            bootbox.alert('Réservation refusée.');
+          }
+          await refreshPending();
+        } catch (e) {
+          showAlert('error', 'Action impossible.');
+        }
+      });
+    }
+
+    // Purge
+    const purgeBtn = document.getElementById('onekite-purge');
+    if (purgeBtn) {
+      purgeBtn.addEventListener('click', async () => {
+        const yearInput = document.getElementById('onekite-purge-year');
+        const year = (yearInput ? yearInput.value : '').trim();
+        if (!/^\d{4}$/.test(year)) {
+          showAlert('error', 'Année invalide (YYYY)');
+          return;
+        }
+        bootbox.confirm(`Purger toutes les réservations de ${year} ?`, async (ok) => {
+          if (!ok) return;
+          try {
+            const r = await purge(year);
+            showAlert('success', `Purge OK (${r.removed || 0} supprimées).`);
+            await refreshPending();
+          } catch (e) {
+            showAlert('error', 'Purge impossible.');
+          }
+        });
+      });
+    }
+
+    // Purge special events by year
+    const sePurgeBtn = document.getElementById('onekite-se-purge');
+    if (sePurgeBtn) {
+      sePurgeBtn.addEventListener('click', async () => {
+        const yearInput = document.getElementById('onekite-se-purge-year');
+        const year = (yearInput ? yearInput.value : '').trim();
+        if (!/^\d{4}$/.test(year)) {
+          showAlert('error', 'Année invalide (YYYY)');
+          return;
+        }
+        bootbox.confirm(`Purger tous les évènements de ${year} ?`, async (ok) => {
+          if (!ok) return;
+          try {
+            const r = await purgeSpecialEvents(year);
+            showAlert('success', `Purge OK (${r.removed || 0} supprimé(s)).`);
+          } catch (e) {
+            showAlert('error', 'Purge impossible.');
+          }
+        });
+      });
+    }
+
+    // Debug
+    const debugBtn = document.getElementById('onekite-debug-run');
+    if (debugBtn) {
+      debugBtn.addEventListener('click', async () => {
+        const out = document.getElementById('onekite-debug-output');
+        if (out) out.textContent = 'Chargement...';
+        try {
+          const result = await debugHelloAsso();
+          if (out) out.textContent = JSON.stringify(result, null, 2);
+          const catalogCount = result && result.catalog ? parseInt(result.catalog.count, 10) || 0 : 0;
+          const catalogOk = !!(result && result.catalog && result.catalog.ok);
+          // Accept "count > 0" even if ok flag is false (some proxies can strip fields, etc.)
+          if (catalogOk || catalogCount > 0) {
+            showAlert('success', `Catalogue HelloAsso: ${catalogCount} item(s)`);
+          } else {
+            showAlert('error', 'HelloAsso: impossible de récupérer le catalogue.');
+          }
+        } catch (e) {
+          if (out) out.textContent = String(e && e.message ? e.message : e);
+          showAlert('error', 'Debug impossible.');
+        }
+      });
+    }
+
+    // Accounting (paid reservations)
+    const accFrom = document.getElementById('onekite-acc-from');
+    const accTo = document.getElementById('onekite-acc-to');
+    const accRefresh = document.getElementById('onekite-acc-refresh');
+    const accExport = document.getElementById('onekite-acc-export');
+    const accPurge = document.getElementById('onekite-acc-purge');
+    const accSummary = document.querySelector('#onekite-acc-summary tbody');
+    const accRows = document.querySelector('#onekite-acc-rows tbody');
+
+    function ymd(d) {
+      const yyyy = d.getUTCFullYear();
+      const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+      const dd = String(d.getUTCDate()).padStart(2, '0');
+      return `${yyyy}-${mm}-${dd}`;
+    }
+    if (accFrom && accTo) {
+      const now = new Date();
+      const to = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1));
+      const from = new Date(Date.UTC(now.getUTCFullYear() - 1, now.getUTCMonth() + 1, 1));
+      if (!accFrom.value) accFrom.value = ymd(from);
+      if (!accTo.value) accTo.value = ymd(to);
+    }
+
+    function renderAccounting(payload) {
+      if (accSummary) accSummary.innerHTML = '';
+      if (accRows) accRows.innerHTML = '';
+      if (!payload || !payload.ok) {
+        return;
+      }
+
+      (payload.summary || []).forEach((s) => {
+        const tr = document.createElement('tr');
+        tr.innerHTML = `<td>${escapeHtml(s.item)}</td><td>${escapeHtml(String(s.count || 0))}</td><td>${escapeHtml((Number(s.total) || 0).toFixed(2))}</td>`;
+        accSummary && accSummary.appendChild(tr);
+      });
+
+      (payload.rows || []).forEach((r) => {
+        const tr = document.createElement('tr');
+        const user = r.username ? `<a href="/user/${encodeURIComponent(r.username)}" target="_blank">${escapeHtml(r.username)}</a>` : '';
+        const items = Array.isArray(r.items) ? r.items.map((x) => escapeHtml(x)).join('<br>') : '';
+        tr.innerHTML = `<td>${escapeHtml(r.startDate)} → ${escapeHtml(r.endDate)}</td><td>${user}</td><td>${items}</td><td>${escapeHtml((Number(r.total) || 0).toFixed(2))}</td><td><code>${escapeHtml(r.rid)}</code></td>`;
+        accRows && accRows.appendChild(tr);
+      });
+    }
+
+    async function refreshAccounting() {
+      if (!accRefresh) return;
+      try {
+        const from = accFrom ? accFrom.value : '';
+        const to = accTo ? accTo.value : '';
+        accRefresh.disabled = true;
+        const payload = await loadAccounting(from, to);
+        renderAccounting(payload);
+      } catch (e) {
+        showAlert('error', 'Impossible de charger la comptabilisation.');
+      } finally {
+        accRefresh.disabled = false;
+      }
+    }
+
+    if (accRefresh) {
+      accRefresh.addEventListener('click', refreshAccounting);
+      // Load once on init
+      refreshAccounting();
+    }
+    if (accExport) {
+      accExport.addEventListener('click', () => {
+        const params = new URLSearchParams();
+        if (accFrom && accFrom.value) params.set('from', accFrom.value);
+        if (accTo && accTo.value) params.set('to', accTo.value);
+        const qs = params.toString();
+        const url = `/api/v3/admin/plugins/calendar-onekite/accounting.csv${qs ? `?${qs}` : ''}`;
+        window.open(url, '_blank');
+      });
+
+      if (accPurge) {
+        accPurge.addEventListener('click', async () => {
+          const ok = window.confirm('Purger la comptabilité pour la période sélectionnée ?\nCela masquera ces réservations dans l\'onglet Comptabilisation (sans modifier leur statut payé).');
+          if (!ok) return;
+          try {
+            const params = new URLSearchParams();
+            if (accFrom && accFrom.value) params.set('from', accFrom.value);
+            if (accTo && accTo.value) params.set('to', accTo.value);
+            const qs = params.toString();
+            const url = `/api/v3/admin/plugins/calendar-onekite/accounting/purge${qs ? `?${qs}` : ''}`;
+            const res = await fetchJson(url, { method: 'POST' });
+            if (res && res.ok) {
+              showAlert('success', `Compta purgée : ${res.purged || 0} réservation(s).`);
+              // Refresh accounting tables after purge
+              try {
+                const from = accFrom ? accFrom.value : '';
+                const to = accTo ? accTo.value : '';
+                const data = await loadAccounting(from, to);
+                renderAccounting(data);
+              } catch (e) {
+                // If refresh fails, keep the success message and show a soft warning
+                showAlert('error', 'Compta purgée, mais rafraîchissement impossible.');
+              }
+            } else {
+              showAlert('error', 'Purge impossible.');
+            }
+          } catch (e) {
+            showAlert('error', 'Purge impossible.');
+          }
+        });
+      }
+
+    }
+  }
+
+  return { init };
+});

package/public/admin.js

@@ -1,5 +1,22 @@
+/* global app, ajaxify, bootbox, alerts */
+(function (factory) {
+  if (typeof define === 'function' && define.amd) {
+    define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], factory);
+  } else {
+    // No RequireJS in this ACP context; fallback to globals
+    var mod = factory(window.alerts || null, window.bootbox || null);
+    if (mod && typeof mod.init === 'function') {
+      if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', mod.init);
+      } else {
+        mod.init();
+      }
+      document.addEventListener('action:ajaxify.end', mod.init);
+    }
+  }
+})(function (alerts, bootbox) {
+  'use strict';
 
-define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts, bootbox) {
   'use strict';
 
   function showAlert(type, msg) {
@@ -758,4 +775,5 @@ define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts
   }
 
   return { init };
+
 });