nodebb-plugin-onekite-calendar 1.0.0

package/public/admin.js

@@ -0,0 +1,812 @@
+
+define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts, bootbox) {
+  'use strict';
+
+  // Cache of pending reservations keyed by rid so delegated click handlers
+  // can open rich modals without embedding large JSON blobs into the DOM.
+  const pendingCache = new Map();
+
+  function showAlert(type, msg) {
+    // Deduplicate identical alerts that can be triggered multiple times
+    // by NodeBB ACP save buttons/hooks across ajaxify navigations.
+    try {
+      const now = Date.now();
+      const last = window.oneKiteCalendarLastAlert;
+      if (last && last.type === type && last.msg === msg && (now - last.ts) < 1200) {
+        return;
+      }
+      window.oneKiteCalendarLastAlert = { type, msg, ts: now };
+    } catch (e) {}
+    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 = '';
+
+    pendingCache.clear();
+
+    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) {
+      if (r && r.rid) pendingCache.set(String(r.rid), r);
+      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 onekite-pending-row';
+      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">
+            <!-- IMPORTANT: type="button" to avoid submitting the settings form and resetting ACP tabs -->
+            <button type="button" class="btn btn-outline-danger btn-sm" data-action="refuse" data-rid="${escapeHtml(String(r.rid || ''))}">Refuser</button>
+            <button type="button" class="btn btn-success btn-sm" data-action="approve" data-rid="${escapeHtml(String(r.rid || ''))}">Valider</button>
+          </div>
+        </div>
+      `;
+      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, payload) {
+    return await fetchJson(`/api/v3/admin/plugins/calendar-onekite/reservations/${rid}/refuse`, {
+      method: 'PUT',
+      body: JSON.stringify(payload || {}),
+    });
+  }
+
+  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/v3/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/v3/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;
+
+    // Make the HelloAsso debug output readable in both light and dark ACP themes.
+    // NodeBB 4.x uses Bootstrap variables, so we can rely on CSS variables here.
+    (function injectAdminCss() {
+      const id = 'onekite-admin-css';
+      if (document.getElementById(id)) return;
+      const style = document.createElement('style');
+      style.id = id;
+      style.textContent = `
+        #onekite-debug-output.onekite-debug-output {
+          background: var(--bs-body-bg) !important;
+          color: var(--bs-body-color) !important;
+          border: 1px solid var(--bs-border-color) !important;
+        }
+      `;
+      document.head.appendChild(style);
+    })();
+
+    // 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;
+      }
+    }
+
+    // Expose the latest save handler so the global delegated listener (bound once)
+    // can always call the current instance tied to the current form.
+    window.oneKiteCalendarAdminDoSave = doSave;
+
+    // Save buttons (NodeBB header/footer "Enregistrer" + floppy icon)
+    // Bind a SINGLE delegated listener for the entire admin session.
+    const SAVE_SELECTOR = '#save, .save, [data-action="save"], .settings-save, .floating-save, .btn[data-action="save"]';
+    if (!window.oneKiteCalendarAdminBound) {
+      window.oneKiteCalendarAdminBound = true;
+      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;
+        const fn = window.oneKiteCalendarAdminDoSave;
+        if (typeof fn === 'function') fn(ev);
+      });
+    }
+
+    // Approve/refuse buttons
+    const pendingWrap = document.getElementById('onekite-pending');
+    if (pendingWrap && !pendingWrap.dataset.okcBound) {
+      pendingWrap.dataset.okcBound = '1';
+      pendingWrap.addEventListener('click', async (ev) => {
+        const btn = ev.target && ev.target.closest('button[data-action]');
+        if (!btn) return;
+        // Prevent the settings form from submitting (default <button> behavior)
+        // and avoid triggering NodeBB ACP tab navigation side-effects.
+        try {
+          ev.preventDefault();
+          ev.stopPropagation();
+        } catch (e) {}
+        const action = btn.getAttribute('data-action');
+        const rid = btn.getAttribute('data-rid');
+        if (!rid) return;
+
+        // Remove the row immediately on success for a snappier UX
+        const rowEl = btn.closest('tr') || btn.closest('.onekite-pending-row');
+
+        try {
+          if (action === 'refuse') {
+            const html = `
+              <div class="mb-3">
+                <label class="form-label">Raison du refus</label>
+                <textarea class="form-control" id="onekite-refuse-reason" rows="3" placeholder="Ex: matériel indisponible, dates impossibles, dossier incomplet..."></textarea>
+              </div>
+            `;
+            const ok = await new Promise((resolve) => {
+              bootbox.dialog({
+                title: 'Refuser la réservation',
+                message: html,
+                buttons: {
+                  cancel: { label: 'Annuler', className: 'btn-secondary', callback: () => resolve(false) },
+                  ok: {
+                    label: 'Refuser',
+                    className: 'btn-danger',
+                    callback: async () => {
+                      try {
+                        const reason = (document.getElementById('onekite-refuse-reason')?.value || '').trim();
+                        await refuse(rid, { reason });
+                        if (rowEl && rowEl.parentNode) rowEl.parentNode.removeChild(rowEl);
+                        showAlert('success', 'Demande refusée.');
+                        resolve(true);
+                      } catch (e) {
+                        showAlert('error', 'Refus impossible.');
+                        resolve(false);
+                      }
+                      return false;
+                    },
+                  },
+                },
+              });
+            });
+            if (ok) {
+              await refreshPending();
+            }
+            return;
+          }
+
+          if (action === 'approve') {
+            const r = pendingCache.get(String(rid)) || {};
+            const itemNames = Array.isArray(r.itemNames) && r.itemNames.length
+              ? r.itemNames
+              : (typeof r.itemNames === 'string' && r.itemNames.trim()
+                ? r.itemNames.split(',').map(s => s.trim()).filter(Boolean)
+                : ([r.itemName || r.itemId].filter(Boolean)));
+            const itemsListHtml = itemNames.length
+              ? `<div class="mb-2"><strong>Matériel</strong><ul style="margin:0.25rem 0 0 1.1rem; padding:0;">${itemNames.map(n => `<li>${escapeHtml(String(n))}</li>`).join('')}</ul></div>`
+              : '';
+            const opts = timeOptions(5).map(t => `<option value="${t}" ${t === '07:00' ? 'selected' : ''}>${t}</option>`).join('');
+
+            const html = `
+              ${itemsListHtml}
+              <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" id="onekite-map-help">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();
+                      await approve(rid, { pickupAddress, notes, pickupTime, pickupLat, pickupLon });
+                      if (rowEl && rowEl.parentNode) rowEl.parentNode.removeChild(rowEl);
+                      showAlert('success', 'Demande validée.');
+                      await refreshPending();
+                    } catch (e) {
+                      showAlert('error', 'Validation impossible.');
+                    }
+                    return false;
+                  },
+                },
+              },
+            });
+
+            // Init Leaflet map once the modal is visible.
+            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);
+
+                // Default view (France-ish)
+                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) {
+                // ignore
+              }
+            });
+          }
+        } 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, ${r.archivedForAccounting || 0} archivées — compta conservée).`);
+            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 };
+});