nodebb-plugin-onekite-calendar 2.0.11 → 2.0.13

package/pkg/package/public/admin.js

@@ -0,0 +1,1477 @@
+
+define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts, bootbox) {
+  'use strict';
+
+  // ACP dark mode compatibility: style the address autocomplete dropdown using
+  // Bootstrap CSS variables (so it remains readable in dark themes).
+  (function ensureOnekiteAdminStyles() {
+    try {
+      if (document.getElementById('onekite-acp-inline-styles')) return;
+      const style = document.createElement('style');
+      style.id = 'onekite-acp-inline-styles';
+      style.textContent = `
+        .onekite-autocomplete-menu {
+          background: var(--bs-body-bg, #fff);
+          color: var(--bs-body-color, #212529);
+          border: 1px solid var(--bs-border-color, rgba(0,0,0,.15));
+          box-shadow: 0 .5rem 1rem rgba(0,0,0,.15);
+        }
+        .onekite-autocomplete-item {
+          color: inherit;
+          background: transparent;
+        }
+        .onekite-autocomplete-item:hover,
+        .onekite-autocomplete-item:focus {
+          background: var(--bs-tertiary-bg, rgba(0,0,0,.05));
+          outline: none;
+        }
+      `;
+      document.head.appendChild(style);
+    } catch (e) {
+      // ignore
+    }
+  })();
+
+  // 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();
+
+  // Prevent double actions (double taps/clicks) in ACP.
+  // Keyed by action (eg. approve:RID, refuse:RID, batch:approve).
+  const actionLocks = new Set();
+
+  function setButtonsDisabled(btns, disabled) {
+    (btns || []).filter(Boolean).forEach((b) => {
+      try {
+        b.disabled = !!disabled;
+        b.classList.toggle('disabled', !!disabled);
+        b.setAttribute('aria-disabled', disabled ? 'true' : 'false');
+      } catch (e) {}
+    });
+  }
+
+  function setBtnBusy(btn, busy) {
+    if (!btn) return;
+    try {
+      if (busy) {
+        if (!btn.dataset.okcOrigHtml) btn.dataset.okcOrigHtml = btn.innerHTML;
+        btn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true" style="margin-right:6px;"></span>' + btn.dataset.okcOrigHtml;
+      } else if (btn.dataset.okcOrigHtml) {
+        btn.innerHTML = btn.dataset.okcOrigHtml;
+      }
+    } catch (e) {}
+  }
+
+  async function withLock(lockKey, btns, fn) {
+    if (!lockKey) return await fn();
+    if (actionLocks.has(lockKey)) return;
+    actionLocks.add(lockKey);
+    setButtonsDisabled(btns, true);
+    // Only show a spinner on the primary button (first in list)
+    setBtnBusy(btns && btns[0], true);
+    try {
+      return await fn();
+    } finally {
+      setBtnBusy(btns && btns[0], false);
+      setButtonsDisabled(btns, false);
+      actionLocks.delete(lockKey);
+    }
+  }
+
+  function getActiveBootboxFooterButtons() {
+    try {
+      const modal = document.querySelector('.bootbox.modal.show');
+      if (!modal) return [];
+      return Array.from(modal.querySelectorAll('.modal-footer button'));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  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 };
+  }
+
+  // Lightweight address autocomplete (OpenStreetMap Nominatim)
+  // Designed to work inside Bootstrap "input-group" without moving DOM nodes.
+  async function searchAddresses(query, limit) {
+    const q = String(query || '').trim();
+    const lim = Math.min(10, Math.max(1, Number(limit) || 6));
+    if (q.length < 3) return [];
+    const url = `https://nominatim.openstreetmap.org/search?format=jsonv2&addressdetails=1&limit=${lim}&q=${encodeURIComponent(q)}`;
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Accept-Language': 'fr',
+      },
+    });
+    if (!res.ok) return [];
+    const arr = await res.json();
+    if (!Array.isArray(arr)) return [];
+    return arr.map((hit) => {
+      const lat = Number(hit.lat);
+      const lon = Number(hit.lon);
+      return {
+        displayName: hit.display_name || q,
+        lat: Number.isFinite(lat) ? lat : null,
+        lon: Number.isFinite(lon) ? lon : null,
+      };
+    }).filter(h => h && h.displayName);
+  }
+
+  function attachAddressAutocomplete(inputEl, onPick) {
+    if (!inputEl) return;
+    if (inputEl.getAttribute('data-onekite-autocomplete') === '1') return;
+    inputEl.setAttribute('data-onekite-autocomplete', '1');
+
+    // In Bootstrap input-groups (especially in ACP), wrapping the input breaks layout.
+    // So we anchor the menu to the closest input-group (or parent) without moving the input.
+    const anchor = inputEl.closest && inputEl.closest('.input-group')
+      ? inputEl.closest('.input-group')
+      : (inputEl.parentNode || document.body);
+
+    try {
+      const cs = window.getComputedStyle(anchor);
+      if (!cs || cs.position === 'static') {
+        anchor.style.position = 'relative';
+      }
+    } catch (e) {
+      anchor.style.position = 'relative';
+    }
+
+    const menu = document.createElement('div');
+    menu.className = 'onekite-autocomplete-menu';
+    menu.style.position = 'absolute';
+    menu.style.left = '0';
+    menu.style.right = '0';
+    menu.style.top = '100%';
+    menu.style.zIndex = '2000';
+    // Colors are handled via CSS variables (supports ACP dark mode).
+    menu.style.borderTop = '0';
+    menu.style.maxHeight = '220px';
+    menu.style.overflowY = 'auto';
+    menu.style.display = 'none';
+    menu.style.borderRadius = '0 0 .375rem .375rem';
+    anchor.appendChild(menu);
+
+    let timer = null;
+    let lastQuery = '';
+    let busy = false;
+
+    function hide() {
+      menu.style.display = 'none';
+      menu.innerHTML = '';
+    }
+
+    function show(hits) {
+      if (!hits || !hits.length) {
+        hide();
+        return;
+      }
+      menu.innerHTML = '';
+      hits.forEach((h) => {
+        const btn = document.createElement('button');
+        btn.type = 'button';
+        btn.className = 'onekite-autocomplete-item';
+        btn.textContent = h.displayName;
+        btn.style.display = 'block';
+        btn.style.width = '100%';
+        btn.style.textAlign = 'left';
+        btn.style.padding = '.35rem .5rem';
+        btn.style.border = '0';
+        btn.style.cursor = 'pointer';
+        btn.addEventListener('click', () => {
+          inputEl.value = h.displayName;
+          hide();
+          try { onPick && onPick(h); } catch (e) {}
+        });
+        menu.appendChild(btn);
+      });
+      menu.style.display = 'block';
+    }
+
+    async function run(q) {
+      if (busy) return;
+      busy = true;
+      try {
+        const hits = await searchAddresses(q, 6);
+        if (String(inputEl.value || '').trim() !== q) return; // ignore stale
+        show(hits);
+      } catch (e) {
+        hide();
+      } finally {
+        busy = false;
+      }
+    }
+
+    inputEl.addEventListener('input', () => {
+      const q = String(inputEl.value || '').trim();
+      lastQuery = q;
+      if (timer) clearTimeout(timer);
+      if (q.length < 3) {
+        hide();
+        return;
+      }
+      timer = setTimeout(() => run(lastQuery), 250);
+    });
+
+    inputEl.addEventListener('focus', () => {
+      const q = String(inputEl.value || '').trim();
+      if (q.length >= 3) {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => run(q), 150);
+      }
+    });
+
+    inputEl.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') hide();
+    });
+
+    // Close when clicking outside (once per menu)
+    document.addEventListener('click', (e) => {
+      try {
+        if (!anchor.contains(e.target)) hide();
+      } catch (err) {}
+    });
+  }
+
+  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;
+    }
+
+    // Batch actions (low volume but handy on mobile / multiple requests)
+    const batchBar = document.createElement('div');
+    batchBar.className = 'd-flex flex-wrap gap-2 align-items-center mb-2';
+    batchBar.innerHTML = `
+      <button type="button" class="btn btn-outline-secondary btn-sm" data-action="toggle-all">Tout sélectionner</button>
+      <button type="button" class="btn btn-success btn-sm" data-action="approve-selected">Valider sélection</button>
+      <button type="button" class="btn btn-outline-danger btn-sm" data-action="refuse-selected">Refuser sélection</button>
+      <span class="text-muted" style="font-size:12px;">(<span id="onekite-selected-count">0</span> sélectionnée)</span>
+    `;
+    wrap.appendChild(batchBar);
+
+    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;" class="d-flex gap-2">
+            <div style="padding-top: 2px;">
+              <input type="checkbox" class="form-check-input onekite-pending-select" data-rid="${escapeHtml(String(r.rid || ''))}" />
+            </div>
+            <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>
+          <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);
+    }
+
+    // Selected counter
+    try {
+      const countEl = document.getElementById('onekite-selected-count');
+      const refreshCount = () => {
+        const n = wrap.querySelectorAll('.onekite-pending-select:checked').length;
+        if (countEl) countEl.textContent = String(n);
+      };
+      wrap.querySelectorAll('.onekite-pending-select').forEach((cb) => cb.addEventListener('change', refreshCount));
+      refreshCount();
+    } catch (e) {}
+  }
+
+
+  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';
+
+      function selectedRids() {
+        return Array.from(pendingWrap.querySelectorAll('input.onekite-pending-select:checked'))
+          .map(cb => cb.getAttribute('data-rid'))
+          .filter(Boolean);
+      }
+
+      function refreshSelectedCount() {
+        const el = document.getElementById('onekite-selected-count');
+        if (el) el.textContent = String(selectedRids().length);
+      }
+
+      pendingWrap.addEventListener('change', (ev) => {
+        const cb = ev.target && ev.target.closest ? ev.target.closest('input.onekite-pending-select') : null;
+        if (!cb) return;
+        refreshSelectedCount();
+      });
+
+      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');
+
+        // Prevent accidental double-open of modals on mobile/trackpad double taps
+        if (rid && (action === 'approve' || action === 'refuse')) {
+          const openKey = `open:${action}:${rid}`;
+          if (actionLocks.has(openKey)) return;
+          actionLocks.add(openKey);
+          setTimeout(() => actionLocks.delete(openKey), 800);
+        }
+
+        // Batch actions (no rid)
+        if ((action === 'toggle-all' || action === 'approve-selected' || action === 'refuse-selected') && !rid) {
+          const batchBtns = Array.from(pendingWrap.querySelectorAll('button[data-action="toggle-all"], button[data-action="approve-selected"], button[data-action="refuse-selected"]'));
+          const allCbs = Array.from(pendingWrap.querySelectorAll('input.onekite-pending-select'));
+          if (action === 'toggle-all') {
+            const want = allCbs.some(cb => !cb.checked);
+            allCbs.forEach(cb => { cb.checked = want; });
+            refreshSelectedCount();
+            btn.textContent = want ? 'Tout désélectionner' : 'Tout sélectionner';
+            return;
+          }
+
+          const rids = selectedRids();
+          if (!rids.length) {
+            showAlert('error', 'Aucune demande sélectionnée.');
+            return;
+          }
+
+          if (action === 'refuse-selected') {
+            const html = `
+              <div class="mb-3">
+                <label class="form-label">Raison du refus (appliquée à toutes les demandes sélectionnées)</label>
+                <textarea class="form-control" id="onekite-refuse-reason" rows="3" placeholder="Ex: matériel indisponible, dates impossibles, dossier incomplet..."></textarea>
+              </div>
+            `;
+            await new Promise((resolve) => {
+              bootbox.dialog({
+                title: `Refuser ${rids.length} demande(s)`,
+                message: html,
+                buttons: {
+                  cancel: { label: 'Annuler', className: 'btn-secondary', callback: () => resolve(false) },
+                  ok: {
+                    label: 'Refuser',
+                    className: 'btn-danger',
+                    callback: async () => {
+                      await withLock(`batch:refuse`, batchBtns.concat(getActiveBootboxFooterButtons()), async () => {
+                        try {
+                          const reason = (document.getElementById('onekite-refuse-reason')?.value || '').trim();
+                          for (const rr of rids) {
+                            await refuse(rr, { reason });
+                          }
+                          showAlert('success', `${rids.length} demande(s) refusée(s).`);
+                          resolve(true);
+                        } catch (e) {
+                          showAlert('error', 'Refus impossible.');
+                          resolve(false);
+                        }
+                      });
+                      return false;
+                    },
+                  },
+                },
+              });
+            });
+            await refreshPending();
+            return;
+          }
+
+          if (action === 'approve-selected') {
+            const opts = timeOptions(5).map(t => `<option value="${t}" ${t === '07:00' ? 'selected' : ''}>${t}</option>`).join('');
+            const html = `
+              <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>
+              <div class="text-muted" style="font-size:12px;">Ces infos seront appliquées aux ${rids.length} demandes sélectionnées.</div>
+            `;
+            const dlg = bootbox.dialog({
+              title: `Valider ${rids.length} demande(s)` ,
+              message: html,
+              buttons: {
+                cancel: { label: 'Annuler', className: 'btn-secondary' },
+                ok: {
+                  label: 'Valider',
+                  className: 'btn-success',
+                  callback: async () => {
+                    await withLock(`batch:approve`, batchBtns.concat(getActiveBootboxFooterButtons()), 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();
+                        for (const rr of rids) {
+                          await approve(rr, { pickupAddress, notes, pickupTime, pickupLat, pickupLon });
+                        }
+                        showAlert('success', `${rids.length} demande(s) validée(s).`);
+                        await refreshPending();
+                      } catch (e) {
+                        showAlert('error', 'Validation impossible.');
+                      }
+                    });
+                  },
+                },
+              },
+            });
+
+            // 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).setView([45.7640, 4.8357], 12);
+                L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+                  maxZoom: 19,
+                  attribution: '&copy; OpenStreetMap contributors',
+                }).addTo(map);
+                const marker = L.marker([45.7640, 4.8357], { draggable: true }).addTo(map);
+
+                function setLatLon(lat, lon) {
+                  const latEl = document.getElementById('onekite-pickup-lat');
+                  const lonEl = document.getElementById('onekite-pickup-lon');
+                  if (latEl) latEl.value = String(lat);
+                  if (lonEl) lonEl.value = String(lon);
+                }
+                setLatLon(45.7640, 4.8357);
+
+                marker.on('dragend', () => {
+                  const p = marker.getLatLng();
+                  setLatLon(p.lat, p.lng);
+                });
+
+                const btnGeocode = document.getElementById('onekite-geocode');
+                if (btnGeocode) {
+                  btnGeocode.addEventListener('click', async () => {
+                    try {
+                      const addr = (document.getElementById('onekite-pickup-address')?.value || '').trim();
+                      const hit = await geocodeAddress(addr);
+                      if (!hit) return;
+                      marker.setLatLng([hit.lat, hit.lon]);
+                      map.setView([hit.lat, hit.lon], 16);
+                      setLatLon(hit.lat, hit.lon);
+                    } catch (e) {}
+                  });
+                }
+
+                // Autocomplete like on the calendar validation modal
+                const addrInput = document.getElementById('onekite-pickup-address');
+                attachAddressAutocomplete(addrInput, (h) => {
+                  try {
+                    if (!h || !Number.isFinite(Number(h.lat)) || !Number.isFinite(Number(h.lon))) return;
+                    const lat = Number(h.lat);
+                    const lon = Number(h.lon);
+                    marker.setLatLng([lat, lon]);
+                    map.setView([lat, lon], 16);
+                    setLatLon(lat, lon);
+                  } catch (e) {}
+                });
+                setTimeout(() => { try { map.invalidateSize(); } catch (e) {} }, 250);
+              } catch (e) {}
+            });
+            return;
+          }
+        }
+
+        if (!rid) return;
+
+        // Remove the row immediately on success for a snappier UX
+        const rowEl = btn.closest('tr') || btn.closest('.onekite-pending-row');
+        const rowBtns = rowEl ? Array.from(rowEl.querySelectorAll('button[data-action="approve"],button[data-action="refuse"]')) : [btn];
+
+        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 () => {
+                      await withLock(`refuse:${rid}`, rowBtns.concat(getActiveBootboxFooterButtons()), 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 () => {
+                    await withLock(`approve:${rid}`, rowBtns.concat(getActiveBootboxFooterButtons()), 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();
+                    }
+                  });
+                }
+
+                // Autocomplete like on the calendar validation modal
+                attachAddressAutocomplete(addrInput, (h) => {
+                  try {
+                    if (!h || !Number.isFinite(Number(h.lat)) || !Number.isFinite(Number(h.lon))) return;
+                    setMarker(Number(h.lat), Number(h.lon), 16);
+                  } catch (e) {}
+                });
+              } 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).`);
+            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');
+    const accFreeRows = document.querySelector('#onekite-acc-free-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 (accFreeRows) accFreeRows.innerHTML = '';
+      if (!payload || !payload.ok) {
+        return;
+      }
+
+      (payload.summary || []).forEach((s) => {
+        const tr = document.createElement('tr');
+        if (s.isFree) {
+          tr.innerHTML = `<td><em>${escapeHtml(s.item)}</em></td><td>${escapeHtml(String(s.count || 0))}</td><td>-</td>`;
+        } else {
+          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>${r.isFree ? ' <em>(gratuit)</em>' : ''}` : (r.isFree ? '<em>(gratuit)</em>' : '');
+        const items = Array.isArray(r.items) ? r.items.map((x) => escapeHtml(x)).join('<br>') : '';
+        const totalCell = r.isFree ? '-' : escapeHtml((Number(r.total) || 0).toFixed(2));
+        if (r.isFree) {
+          tr.innerHTML = `<td>${escapeHtml(r.startDate)} → ${escapeHtml(r.endDate)}</td><td>${user}</td><td>${items}</td><td><code>${escapeHtml(r.rid)}</code></td>`;
+          accFreeRows && accFreeRows.appendChild(tr);
+        } else {
+          tr.innerHTML = `<td>${escapeHtml(r.startDate)} → ${escapeHtml(r.endDate)}</td><td>${user}</td><td>${items}</td><td>${totalCell}</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.');
+          }
+        });
+      }
+
+    }
+
+    // --------------------
+    // Maintenance (simple ON/OFF)
+    // --------------------
+    const maintSearch = document.getElementById('onekite-maint-search');
+    const maintRefresh = document.getElementById('onekite-maint-refresh');
+    const maintAllOn = document.getElementById('onekite-maint-all-on');
+    const maintAllOff = document.getElementById('onekite-maint-all-off');
+    const maintTableBody = document.querySelector('#onekite-maint-table tbody');
+
+    let maintItemsCache = [];
+    async function loadItemsWithMaintenance() {
+      // Public items endpoint returns catalog + maintenance flag
+      return await fetchJson('/api/v3/plugins/calendar-onekite/items');
+    }
+
+    function renderMaintenanceTable(items) {
+      if (!maintTableBody) return;
+      const q = maintSearch ? String(maintSearch.value || '').trim().toLowerCase() : '';
+      const filtered = (items || []).filter((it) => {
+        if (!it) return false;
+        if (!q) return true;
+        return String(it.name || '').toLowerCase().includes(q);
+      });
+      maintTableBody.innerHTML = filtered.map((it) => {
+        const id = String(it.id);
+        const name = String(it.name || '').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        const checked = it.maintenance ? 'checked' : '';
+        return `<tr data-itemid="${id}">
+          <td>${name}</td>
+          <td>
+            <div class="form-check form-switch">
+              <input class="form-check-input onekite-maint-toggle" type="checkbox" ${checked} />
+            </div>
+          </td>
+        </tr>`;
+      }).join('') || '<tr><td colspan="2" class="text-muted">Aucun matériel.</td></tr>';
+    }
+
+    async function refreshMaintenance() {
+      try {
+        const items = await loadItemsWithMaintenance();
+        maintItemsCache = Array.isArray(items) ? items : [];
+        renderMaintenanceTable(maintItemsCache);
+      } catch (e) {
+        showAlert('error', 'Impossible de charger le matériel (maintenance).');
+      }
+    }
+
+    if (maintRefresh) maintRefresh.addEventListener('click', refreshMaintenance);
+
+    async function setAllMaintenance(enabled) {
+      const label = enabled ? 'mettre TOUS les matériels en maintenance' : 'enlever la maintenance sur TOUS les matériels';
+      const ok = window.confirm(`Confirmer : ${label} ?`);
+      if (!ok) return;
+      try {
+        await fetchJson('/api/v3/plugins/calendar-onekite/maintenance', {
+          method: 'PUT',
+          body: JSON.stringify({ enabled: !!enabled, all: true }),
+        });
+        // Update cache locally without refetching if possible
+        maintItemsCache = maintItemsCache.map((it) => Object.assign({}, it, { maintenance: !!enabled }));
+        renderMaintenanceTable(maintItemsCache);
+        showAlert('success', enabled ? 'Tous les matériels sont en maintenance.' : 'Maintenance supprimée pour tous les matériels.');
+      } catch (e) {
+        showAlert('error', 'Impossible de modifier la maintenance pour tous les matériels.');
+      }
+    }
+
+    if (maintAllOn) maintAllOn.addEventListener('click', () => setAllMaintenance(true));
+    if (maintAllOff) maintAllOff.addEventListener('click', () => setAllMaintenance(false));
+    if (maintSearch) maintSearch.addEventListener('input', () => renderMaintenanceTable(maintItemsCache));
+    if (maintTableBody) {
+      maintTableBody.addEventListener('change', async (ev) => {
+        const el = ev && ev.target;
+        if (!el || !el.classList || !el.classList.contains('onekite-maint-toggle')) return;
+        const tr = el.closest('tr');
+        const itemId = tr ? tr.getAttribute('data-itemid') : '';
+        const enabled = !!el.checked;
+        if (!itemId) return;
+        // Optimistic UI
+        try {
+          await fetchJson(`/api/v3/plugins/calendar-onekite/maintenance/${encodeURIComponent(String(itemId))}`, {
+            method: 'PUT',
+            body: JSON.stringify({ enabled }),
+          });
+          // Update cache
+          maintItemsCache = maintItemsCache.map((it) => (String(it.id) === String(itemId) ? Object.assign({}, it, { maintenance: enabled }) : it));
+          showAlert('success', enabled ? 'Maintenance activée.' : 'Maintenance désactivée.');
+        } catch (e) {
+          // Revert
+          el.checked = !enabled;
+          showAlert('error', 'Impossible de modifier la maintenance.');
+        }
+      });
+    }
+
+    // Load once
+    if (maintTableBody) {
+      refreshMaintenance();
+    }
+
+    // --------------------
+    // Audit (purge par année)
+    // --------------------
+    const auditYearEl = document.getElementById('onekite-audit-year');
+    const auditSearchEl = document.getElementById('onekite-audit-search');
+    const auditRefreshBtn = document.getElementById('onekite-audit-refresh');
+    const auditPurgeBtn = document.getElementById('onekite-audit-purge');
+    const auditTbody = document.querySelector('#onekite-audit-table tbody');
+
+    let auditCache = [];
+    function fmtDateTime(ts) {
+      try {
+        return new Date(Number(ts) || 0).toLocaleString('fr-FR');
+      } catch (e) {
+        return String(ts || '');
+      }
+    }
+    function renderAudit(entries) {
+      if (!auditTbody) return;
+      const q = auditSearchEl ? String(auditSearchEl.value || '').trim().toLowerCase() : '';
+      const rows = (entries || []).filter((e) => {
+        if (!e) return false;
+        if (!q) return true;
+        const hay = [e.action, e.actorUsername, e.targetType, e.targetId, JSON.stringify(e)].join(' ').toLowerCase();
+        return hay.includes(q);
+      }).map((e) => {
+        const actor = e.actorUsername ? `${e.actorUsername} (#${e.actorUid || 0})` : `#${e.actorUid || 0}`;
+        const target = `${e.targetType || ''} ${e.targetId || ''}`.trim();
+        const details = (() => {
+          const parts = [];
+          if (e.itemNames && Array.isArray(e.itemNames) && e.itemNames.length) parts.push(e.itemNames.join(', '));
+          if (e.startDate && e.endDate) parts.push(`${e.startDate} → ${e.endDate}`);
+          if (e.reason) parts.push(`Raison: ${e.reason}`);
+          if (e.removed) parts.push(`Supprimés: ${e.removed}`);
+          return parts.join(' — ');
+        })();
+        return `<tr>
+          <td>${fmtDateTime(e.ts)}</td>
+          <td>${String(actor).replace(/</g,'&lt;').replace(/>/g,'&gt;')}</td>
+          <td>${String(e.action || '').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</td>
+          <td>${String(target).replace(/</g,'&lt;').replace(/>/g,'&gt;')}</td>
+          <td class="text-muted">${String(details || '').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</td>
+        </tr>`;
+      }).join('');
+      auditTbody.innerHTML = rows || '<tr><td colspan="5" class="text-muted">Aucune entrée.</td></tr>';
+    }
+
+    async function refreshAudit() {
+      if (!auditTbody) return;
+      const y = Number((auditYearEl && auditYearEl.value) || new Date().getFullYear());
+      try {
+        const data = await fetchJson(`/api/v3/plugins/calendar-onekite/audit?year=${encodeURIComponent(String(y))}&limit=300`);
+        auditCache = (data && data.entries) ? data.entries : [];
+        renderAudit(auditCache);
+      } catch (e) {
+        showAlert('error', 'Impossible de charger l\'audit.');
+      }
+    }
+
+    if (auditYearEl && !auditYearEl.value) {
+      auditYearEl.value = String(new Date().getFullYear());
+    }
+    if (auditRefreshBtn) auditRefreshBtn.addEventListener('click', refreshAudit);
+    if (auditSearchEl) auditSearchEl.addEventListener('input', () => renderAudit(auditCache));
+    if (auditPurgeBtn) {
+      auditPurgeBtn.addEventListener('click', async () => {
+        const y = Number((auditYearEl && auditYearEl.value) || 0);
+        if (!y) return;
+        const ok = window.confirm(`Purger définitivement l’audit de l’année ${y} ?`);
+        if (!ok) return;
+        try {
+          const res = await fetchJson('/api/v3/plugins/calendar-onekite/audit/purge', {
+            method: 'POST',
+            body: JSON.stringify({ year: y }),
+          });
+          showAlert('success', `Audit purgé : ${res && res.removed ? res.removed : 0} entrée(s).`);
+          await refreshAudit();
+        } catch (e) {
+          showAlert('error', 'Purge audit impossible.');
+        }
+      });
+    }
+
+    // Load once
+    if (auditTbody) {
+      refreshAudit();
+    }
+  }
+
+  return { init };
+});