nodebb-plugin-calendar-onekite 2.1.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-calendar-onekite",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Calendar + equipment booking + admin approval + HelloAsso payments for NodeBB v4 (no-jQuery UI)",
   "main": "library.js",
   "license": "MIT",

package/plugin.json

@@ -3,13 +3,13 @@
   "name": "Calendar Onekite",
   "description": "Calendrier + réservation matériel + validation admin + paiement HelloAsso pour NodeBB v4 (no-jQuery UI)",
   "url": "",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "library": "./library.js",
   "staticDirs": {
     "static": "static"
   },
   "acpScripts": [
-    "static/js/admin.js"
+    "static/js/admin.bundle.js"
   ],
   "hooks": [
     {

package/static/js/admin.bundle.js

@@ -0,0 +1,248 @@
+(function () {
+  'use strict';
+  if (window.__onekiteAdminBundleLoaded) { return; }
+  window.__onekiteAdminBundleLoaded = true;
+
+  function qs(sel, root) { return (root || document).querySelector(sel); }
+  function qsa(sel, root) { return Array.from((root || document).querySelectorAll(sel)); }
+  function escapeHtml(s) {
+    return String(s ?? '')
+      .replaceAll('&','&amp;').replaceAll('<','&lt;').replaceAll('>','&gt;')
+      .replaceAll('"','&quot;').replaceAll("'","&#039;");
+  }
+
+  function onReady(fn) {
+    if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', fn, { once: true });
+    else fn();
+  }
+
+  function boot(api, alerts) {
+    const STATE = { bound: false, fc: null, locations: [], inventory: [], rows: [] };
+
+    async function saveSettings() {
+      const locationsJson = qs('#calendar-onekite-locations')?.value || '[]';
+      const inventoryJson = qs('#calendar-onekite-inventory')?.value || '[]';
+
+      try { JSON.parse(locationsJson || '[]'); } catch { return alerts.error('JSON Lieux invalide'); }
+      try { JSON.parse(inventoryJson || '[]'); } catch { return alerts.error('JSON Inventaire invalide'); }
+
+      const settings = {
+        allowedGroups: qs('#calendar-onekite-groups')?.value || 'administrators',
+        allowedBookingGroups: qs('#calendar-onekite-book-groups')?.value || 'registered-users',
+        limit: qs('#calendar-onekite-widget-limit')?.value || '5',
+        locationsJson,
+        inventoryJson,
+        helloassoApiBase: qs('#calendar-onekite-helloasso-apibase')?.value || '',
+        helloassoOrganizationSlug: qs('#calendar-onekite-helloasso-org')?.value || '',
+        helloassoFormSlug: qs('#calendar-onekite-helloasso-form')?.value || '',
+        helloassoClientId: qs('#calendar-onekite-helloasso-clientid')?.value || '',
+        helloassoClientSecret: qs('#calendar-onekite-helloasso-secret')?.value || '',
+        helloassoReturnUrl: qs('#calendar-onekite-helloasso-return')?.value || '',
+      };
+
+      try {
+        await api.put('/admin/plugins/calendar-onekite', settings);
+        alerts.success('Paramètres enregistrés');
+      } catch (e) {
+        console.error('[calendar-onekite] saveSettings error', e);
+        alerts.error(e?.message || e);
+      }
+    }
+
+    function bindAdminSettings() {
+      const root = qs('#calendar-onekite-admin');
+      if (!root) return;
+
+      // Bind button
+      const btn = qs('#calendar-onekite-save');
+      if (btn && !btn.__bound) {
+        btn.__bound = true;
+        btn.addEventListener('click', saveSettings);
+      }
+
+      // Delegation for pending actions
+      if (!root.__delegationBound) {
+        root.__delegationBound = true;
+        root.addEventListener('click', async (ev) => {
+          const t = ev.target;
+          if (!(t instanceof HTMLElement)) return;
+          const row = t.closest('.reservation-row');
+          if (!row) return;
+          const rid = row.getAttribute('data-rid');
+          if (!rid) return;
+
+          try {
+            if (t.classList.contains('js-validate')) {
+              await api.post(`/admin/calendar/reservation/${encodeURIComponent(rid)}/validate`, {});
+              row.style.background = '#d4edda';
+              qsa('.js-validate, .js-cancel', row).forEach(b => b.remove());
+              row.insertAdjacentHTML('beforeend', '<p><strong>Validée.</strong> Lien de paiement envoyé.</p>');
+            }
+            if (t.classList.contains('js-cancel')) {
+              if (!window.confirm('Annuler cette réservation ?')) return;
+              await api.post(`/admin/calendar/reservation/${encodeURIComponent(rid)}/cancel`, {});
+              row.style.background = '#f8d7da';
+              qsa('.js-validate, .js-cancel', row).forEach(b => b.remove());
+              row.insertAdjacentHTML('beforeend', '<p><strong>Annulée.</strong></p>');
+            }
+          } catch (e) {
+            console.error('[calendar-onekite] pending action error', e);
+            alerts.error(e?.message || e);
+          }
+        });
+      }
+
+      loadPending();
+    }
+
+    async function loadPending() {
+      const container = qs('#pending-reservations');
+      if (!container) return;
+      try {
+        const list = await api.get('/admin/calendar/pending');
+        if (!Array.isArray(list) || !list.length) {
+          container.innerHTML = '<p>Aucune réservation en attente.</p>';
+          return;
+        }
+        container.innerHTML = list.map(block => {
+          const ev = block.event || {};
+          const reservations = Array.isArray(block.reservations) ? block.reservations : [];
+          const rows = reservations.map(r => `
+            <div class="reservation-row mb-2 p-2 border rounded" data-rid="${escapeHtml(r.rid)}">
+              <p><strong>RID :</strong> ${escapeHtml(r.rid)}</p>
+              <p><strong>UID :</strong> ${escapeHtml(r.uid)}</p>
+              <p><strong>Matériel :</strong> ${escapeHtml(r.itemId)}</p>
+              <p><strong>Quantité :</strong> ${escapeHtml(r.quantity)}</p>
+              <p><strong>Dates :</strong> ${escapeHtml(r.dateStart)} → ${escapeHtml(r.dateEnd)} (${escapeHtml(r.days||'')} jours)</p>
+              <p><strong>Lieu :</strong> ${escapeHtml(r.pickupLocationName || r.pickupLocation || 'Non précisé')}</p>
+              <button class="btn btn-success btn-sm js-validate">Valider</button>
+              <button class="btn btn-danger btn-sm js-cancel">Annuler</button>
+            </div>
+          `).join('');
+          return `
+            <div class="card mb-3">
+              <div class="card-header">
+                <strong>${escapeHtml(ev.title)}</strong><br>
+                <small>${escapeHtml(ev.start)} → ${escapeHtml(ev.end)}</small>
+              </div>
+              <div class="card-body">${rows}</div>
+            </div>
+          `;
+        }).join('');
+      } catch (e) {
+        console.error('[calendar-onekite] loadPending error', e);
+        alerts.error(e?.message || e);
+      }
+    }
+
+    // Planning graphical
+    async function loadInventory() {
+      const data = await api.get('/calendar/inventory');
+      STATE.locations = Array.isArray(data?.locations) ? data.locations : [];
+      STATE.inventory = Array.isArray(data?.inventory) ? data.inventory : [];
+    }
+    async function loadPlanningRows() {
+      STATE.rows = await api.get('/admin/calendar/planning');
+      if (!Array.isArray(STATE.rows)) STATE.rows = [];
+    }
+    function fillFilters() {
+      const locSel = qs('#planning-filter-location');
+      const itemSel = qs('#planning-filter-item');
+      if (!locSel || !itemSel) return;
+      locSel.innerHTML = '<option value="">Tous</option>' + STATE.locations.map(l =>
+        `<option value="${escapeHtml(l.id)}">${escapeHtml(l.name||l.id)}</option>`
+      ).join('');
+      itemSel.innerHTML = '<option value="">Tous</option>' + STATE.inventory.map(i =>
+        `<option value="${escapeHtml(i.id)}">${escapeHtml(i.name||i.id)}</option>`
+      ).join('');
+    }
+    function colorForStatus(status) {
+      if (status === 'paid') return '#d4edda';
+      if (status === 'awaiting_payment') return '#fff3cd';
+      if (status === 'pending_admin') return '#cfe2ff';
+      return '#e2e3e5';
+    }
+    function toFcEvents() {
+      const loc = qs('#planning-filter-location')?.value || '';
+      const item = qs('#planning-filter-item')?.value || '';
+      const status = qs('#planning-filter-status')?.value || '';
+      return STATE.rows
+        .filter(r => !loc || r.locationId === loc)
+        .filter(r => !item || r.itemId === item)
+        .filter(r => !status || r.status === status)
+        .map(r => {
+          const end = new Date(r.dateEnd);
+          end.setDate(end.getDate() + 1);
+          const c = colorForStatus(r.status);
+          return {
+            id: String(r.rid),
+            title: `${r.itemName} x${r.quantity} — ${r.pickupLocation} — uid ${r.uid}`,
+            start: r.dateStart,
+            end: end.toISOString().slice(0,10),
+            allDay: true,
+            backgroundColor: c,
+            borderColor: c,
+            extendedProps: r,
+          };
+        });
+    }
+    function renderPlanningCalendar() {
+      const el = qs('#planning-calendar');
+      if (!el) return;
+      const FC = window.FullCalendar;
+      if (!FC) return alerts.error('FullCalendar non chargé (CDN bloqué ?)');
+
+      if (STATE.fc) {
+        STATE.fc.removeAllEvents();
+        STATE.fc.addEventSource(toFcEvents());
+        return;
+      }
+      STATE.fc = new FC.Calendar(el, {
+        initialView: 'timeGridWeek',
+        height: 'auto',
+        locale: 'fr',
+        firstDay: 1,
+        headerToolbar: { left: 'prev,next today', center: 'title', right: 'timeGridWeek,dayGridMonth,listWeek' },
+        events: toFcEvents(),
+      });
+      STATE.fc.render();
+    }
+    function bindPlanningFilters() {
+      ['#planning-filter-location', '#planning-filter-item', '#planning-filter-status'].forEach(sel => {
+        qs(sel)?.addEventListener('change', renderPlanningCalendar);
+      });
+    }
+
+    async function initPlanning() {
+      if (!qs('#planning-calendar')) return;
+      try {
+        await Promise.all([loadInventory(), loadPlanningRows()]);
+        fillFilters();
+        bindPlanningFilters();
+        renderPlanningCalendar();
+      } catch (e) {
+        console.error('[calendar-onekite] initPlanning error', e);
+        alerts.error(e?.message || e);
+      }
+    }
+
+    function init() {
+      bindAdminSettings();
+      initPlanning();
+    }
+
+    // NodeBB ajaxify navigation: re-init on page change
+    document.addEventListener('action:ajaxify.end', init);
+    onReady(init);
+    init();
+  }
+
+  // Load NodeBB modules
+  if (typeof require === 'function') {
+    require(['api', 'alerts'], function (api, alerts) {
+      try { boot(api, alerts); } catch (e) { console.error(e); }
+    });
+  } else {
+    console.error('[calendar-onekite] require is not defined');
+  }
+})();

package/static/js/calendar.bundle.js

@@ -0,0 +1,269 @@
+(function () {
+  'use strict';
+  if (window.__onekiteCalendarBundleLoaded) { return; }
+  window.__onekiteCalendarBundleLoaded = true;
+
+  function qs(sel, root) { return (root || document).querySelector(sel); }
+  function qsa(sel, root) { return Array.from((root || document).querySelectorAll(sel)); }
+  function show(el){ if (el) el.style.display='block'; }
+  function hide(el){ if (el) el.style.display='none'; }
+  function escapeHtml(s){
+    return String(s ?? '')
+      .replaceAll('&','&amp;').replaceAll('<','&lt;').replaceAll('>','&gt;')
+      .replaceAll('"','&quot;').replaceAll("'","&#039;");
+  }
+  function pad(n){ return String(n).padStart(2,'0'); }
+  function toLocalInputValue(iso){
+    if (!iso) return '';
+    const d=new Date(iso);
+    return `${d.getFullYear()}-${pad(d.getMonth()+1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  }
+  function fromLocalInputValue(val){
+    if (!val) return null;
+    const d=new Date(val);
+    if (isNaN(d.getTime())) return null;
+    return d.toISOString();
+  }
+
+  function boot(api, alerts) {
+    const STATE = { inited:false, fc:null, currentEid:null, canCreate:false, canBook:false, locations:[], inventory:[] };
+
+    async function loadPermissions() {
+      try {
+        const [c,b]=await Promise.all([api.get('/calendar/permissions/create'), api.get('/calendar/permissions/book')]);
+        STATE.canCreate=!!c?.allow; STATE.canBook=!!b?.allow;
+      } catch { STATE.canCreate=false; STATE.canBook=false; }
+    }
+    async function loadInventory() {
+      try {
+        const data=await api.get('/calendar/inventory');
+        STATE.locations=Array.isArray(data?.locations)?data.locations:[];
+        STATE.inventory=Array.isArray(data?.inventory)?data.inventory:[];
+      } catch { STATE.locations=[]; STATE.inventory=[]; }
+    }
+
+    function bindModalClose() {
+      qsa('.calendar-close').forEach(btn=>{
+        if (btn.__bound) return;
+        btn.__bound=true;
+        btn.addEventListener('click',()=>hide(btn.closest('.calendar-modal')));
+      });
+    }
+
+    function renderBookingChecklist(selectedIds) {
+      const root=qs('#booking-items');
+      if (!root) return;
+      const sel=new Set((selectedIds||[]).map(String));
+      if (!STATE.inventory.length) { root.innerHTML='<p class="text-muted">Aucun matériel (configurez l’inventaire dans l’admin).</p>'; return; }
+      root.innerHTML=STATE.inventory.map(item=>{
+        const checked=sel.has(String(item.id))?'checked':'';
+        return `<div class="form-check">
+          <label class="form-check-label">
+            <input class="form-check-input js-book-item" type="checkbox" value="${escapeHtml(item.id)}" ${checked}>
+            ${escapeHtml(item.name||item.id)} — ${Number(item.price||0)} €/jour
+          </label>
+        </div>`;
+      }).join('');
+    }
+    function readSelectedItemIds() {
+      return qsa('.js-book-item').filter(el=>el.checked).map(el=>String(el.value));
+    }
+
+    function resetEventModal() {
+      STATE.currentEid=null;
+      qs('#event-modal-title').textContent='Nouvel événement';
+      qs('#event-title').value='';
+      qs('#event-description').value='';
+      qs('#event-start').value='';
+      qs('#event-end').value='';
+      qs('#event-allDay').checked=false;
+      qs('#event-location').value='';
+      qs('#event-bookingEnabled').checked=false;
+      renderBookingChecklist([]);
+      qs('#event-delete').style.display='none';
+      qs('#event-reserve').style.display=STATE.canBook?'inline-block':'none';
+    }
+    function fillEventModal(ev) {
+      STATE.currentEid=String(ev.eid);
+      qs('#event-modal-title').textContent='Éditer l’événement';
+      qs('#event-title').value=ev.title||'';
+      qs('#event-description').value=ev.description||'';
+      qs('#event-start').value=toLocalInputValue(ev.start);
+      qs('#event-end').value=toLocalInputValue(ev.end);
+      qs('#event-allDay').checked=!!Number(ev.allDay);
+      qs('#event-location').value=ev.location||'';
+      qs('#event-bookingEnabled').checked=!!Number(ev.bookingEnabled);
+      renderBookingChecklist(ev.bookingItemIds||[]);
+      qs('#event-delete').style.display=STATE.canCreate?'inline-block':'none';
+      qs('#event-reserve').style.display=STATE.canBook?'inline-block':'none';
+    }
+
+    function openEventModalNew(prefill={}) {
+      if (!STATE.canCreate) return alerts.error('Vous n’êtes pas autorisé à créer des événements.');
+      resetEventModal();
+      if (prefill.start) qs('#event-start').value=toLocalInputValue(prefill.start);
+      if (prefill.end) qs('#event-end').value=toLocalInputValue(prefill.end);
+      show(qs('#calendar-event-modal'));
+    }
+    async function openEventModalByEid(eid) {
+      try {
+        const ev=await api.get(`/calendar/event/${encodeURIComponent(eid)}`);
+        fillEventModal(ev);
+        show(qs('#calendar-event-modal'));
+      } catch (e) { console.error(e); alerts.error(e?.message||e); }
+    }
+
+    async function saveEvent() {
+      if (!STATE.canCreate) return;
+      const payload={
+        title: qs('#event-title').value||'',
+        description: qs('#event-description').value||'',
+        start: fromLocalInputValue(qs('#event-start').value)||new Date().toISOString(),
+        end: fromLocalInputValue(qs('#event-end').value)||fromLocalInputValue(qs('#event-start').value)||new Date().toISOString(),
+        allDay: qs('#event-allDay').checked,
+        location: qs('#event-location').value||'',
+        bookingEnabled: qs('#event-bookingEnabled').checked,
+        bookingItemIds: readSelectedItemIds(),
+        visibility:'public',
+      };
+      try {
+        if (STATE.currentEid) await api.put(`/calendar/event/${encodeURIComponent(STATE.currentEid)}`, payload);
+        else await api.post('/calendar/event', payload);
+        alerts.success('Enregistré');
+        hide(qs('#calendar-event-modal'));
+        STATE.fc?.refetchEvents();
+      } catch (e) { console.error(e); alerts.error(e?.message||e); }
+    }
+    async function deleteEvent() {
+      if (!STATE.currentEid || !STATE.canCreate) return;
+      if (!window.confirm('Supprimer cet événement ?')) return;
+      try {
+        await api.del(`/calendar/event/${encodeURIComponent(STATE.currentEid)}`);
+        alerts.success('Supprimé');
+        hide(qs('#calendar-event-modal'));
+        STATE.fc?.refetchEvents();
+      } catch (e) { console.error(e); alerts.error(e?.message||e); }
+    }
+
+    function renderLocationSelect() {
+      const sel=qs('#reserve-location');
+      if (!sel) return;
+      sel.innerHTML = STATE.locations.map(l=>`<option value="${escapeHtml(l.id)}">${escapeHtml(l.name||l.id)}</option>`).join('') || '<option value="">(aucun lieu)</option>';
+    }
+
+    function openReserveModal(ev) {
+      qs('#reserve-title').textContent=`Réserver – ${ev.title||''}`;
+      renderLocationSelect();
+      const allowed=new Set((ev.bookingItemIds||[]).map(String));
+      const items=STATE.inventory.filter(i=>allowed.has(String(i.id)));
+      const reserveItems=qs('#reserve-items');
+      reserveItems.innerHTML = items.length ? items.map(it=>`
+        <div class="form-check">
+          <label class="form-check-label">
+            <input class="form-check-input" type="radio" name="reserveItem" value="${escapeHtml(it.id)}">
+            ${escapeHtml(it.name||it.id)} (${Number(it.price||0)} €/jour)
+          </label>
+        </div>
+      `).join('') : '<p>Aucun matériel réservable pour cet événement.</p>';
+
+      const toDate=(d)=>`${d.getFullYear()}-${pad(d.getMonth()+1)}-${pad(d.getDate())}`;
+      qs('#reserve-start').value=toDate(new Date(ev.start));
+      qs('#reserve-end').value=toDate(new Date(ev.end));
+      show(qs('#calendar-reserve-modal'));
+    }
+
+    async function submitReservation() {
+      const itemId = qs('input[name="reserveItem"]:checked')?.value;
+      const locationId = qs('#reserve-location')?.value;
+      const dateStart = qs('#reserve-start')?.value;
+      const dateEnd = qs('#reserve-end')?.value;
+      const quantity = Number(qs('#reserve-quantity')?.value||1);
+      if (!STATE.currentEid) return alerts.error('Aucun événement sélectionné.');
+      if (!itemId) return alerts.error('Choisissez un matériel.');
+      if (!locationId) return alerts.error('Choisissez un lieu.');
+      try {
+        const res = await api.post(`/calendar/event/${encodeURIComponent(STATE.currentEid)}/book`, { itemId, locationId, dateStart, dateEnd, quantity });
+        alerts.success(res?.message||'Demande envoyée');
+        hide(qs('#calendar-reserve-modal')); hide(qs('#calendar-event-modal'));
+      } catch (e) { console.error(e); alerts.error(e?.message||e); }
+    }
+
+    function bindButtons() {
+      const btnNew=qs('#calendar-new-event');
+      if (btnNew && !btnNew.__bound) { btnNew.__bound=true; btnNew.addEventListener('click', ()=>openEventModalNew()); }
+      const btnSave=qs('#event-save'); if (btnSave && !btnSave.__bound){ btnSave.__bound=true; btnSave.addEventListener('click', saveEvent); }
+      const btnDel=qs('#event-delete'); if (btnDel && !btnDel.__bound){ btnDel.__bound=true; btnDel.addEventListener('click', deleteEvent); }
+      const btnRes=qs('#event-reserve'); if (btnRes && !btnRes.__bound){
+        btnRes.__bound=true;
+        btnRes.addEventListener('click', async ()=>{
+          if (!STATE.canBook) return alerts.error('Vous n’êtes pas autorisé à réserver.');
+          if (!STATE.currentEid) return;
+          try { const ev=await api.get(`/calendar/event/${encodeURIComponent(STATE.currentEid)}`); openReserveModal(ev); }
+          catch(e){ console.error(e); alerts.error(e?.message||e); }
+        });
+      }
+      const btnConf=qs('#reserve-confirm'); if (btnConf && !btnConf.__bound){ btnConf.__bound=true; btnConf.addEventListener('click', submitReservation); }
+    }
+
+    function buildCalendar() {
+      const el=qs('#calendar');
+      if (!el) return;
+      const FC=window.FullCalendar;
+      if (!FC) return alerts.error('FullCalendar non chargé (CDN bloqué ?)');
+      STATE.fc = new FC.Calendar(el, {
+        initialView:'dayGridMonth',
+        height:'auto',
+        locale:'fr',
+        firstDay:1,
+        headerToolbar:{ left:'prev,next today', center:'title', right:'dayGridMonth,timeGridWeek,timeGridDay,listWeek' },
+        selectable:(STATE.canCreate||STATE.canBook),
+        selectMirror:true,
+        editable:STATE.canCreate,
+        events: async (info, success, failure)=>{
+          try{
+            const events=await api.get(`/calendar/events?start=${encodeURIComponent(info.start.toISOString())}&end=${encodeURIComponent(info.end.toISOString())}`);
+            success((events||[]).map(ev=>({ id:String(ev.eid), title:ev.title, start:ev.start, end:ev.end, allDay:!!Number(ev.allDay) })));
+          } catch(e){ failure(e); }
+        },
+        select:(sel)=>{
+          if (STATE.canCreate) return openEventModalNew({ start: sel.startStr, end: sel.endStr });
+          if (STATE.canBook) return alerts.info('Cliquez sur un événement puis "Réserver"');
+        },
+        eventClick:(arg)=>openEventModalByEid(arg.event.id),
+      });
+      STATE.fc.render();
+    }
+
+    async function init() {
+      if (!qs('#calendar')) return;
+      bindModalClose();
+      bindButtons();
+
+      await Promise.all([loadPermissions(), loadInventory()]);
+      const btn=qs('#calendar-new-event');
+      if (btn) btn.style.display = STATE.canCreate ? 'inline-block' : 'none';
+
+      renderBookingChecklist([]);
+      if (!STATE.fc) buildCalendar();
+    }
+
+    document.addEventListener('action:ajaxify.end', init);
+    init();
+  }
+
+  function bindModalClose() {
+    qsa('.calendar-close').forEach(btn=>{
+      if (btn.__bound) return;
+      btn.__bound=true;
+      btn.addEventListener('click',()=>hide(btn.closest('.calendar-modal')));
+    });
+  }
+
+  if (typeof require === 'function') {
+    require(['api','alerts'], function(api, alerts){
+      try { boot(api, alerts); } catch(e){ console.error(e); }
+    });
+  } else {
+    console.error('[calendar-onekite] require is not defined');
+  }
+})();

package/static/js/my-reservations.bundle.js

@@ -0,0 +1,42 @@
+(function(){
+  'use strict';
+  if (window.__onekiteMyResLoaded) return;
+  window.__onekiteMyResLoaded=true;
+
+  function qs(sel, root){ return (root||document).querySelector(sel); }
+  function escapeHtml(s){
+    return String(s ?? '').replaceAll('&','&amp;').replaceAll('<','&lt;').replaceAll('>','&gt;')
+      .replaceAll('"','&quot;').replaceAll("'","&#039;");
+  }
+
+  function boot(api, alerts){
+    async function load(){
+      const tbody=qs('#my-reservations-body');
+      if (!tbody) return;
+      try{
+        const rows=await api.get('/calendar/my-reservations');
+        if (!rows || !rows.length){
+          tbody.innerHTML='<tr><td colspan="7">Aucune réservation.</td></tr>'; return;
+        }
+        tbody.innerHTML = rows.map(r=>`
+          <tr>
+            <td>${escapeHtml(r.eventTitle)}</td>
+            <td>${escapeHtml(r.itemName)}</td>
+            <td>${escapeHtml(r.pickupLocation || '')}</td>
+            <td>${escapeHtml(r.dateStart)}</td>
+            <td>${escapeHtml(r.dateEnd)}</td>
+            <td>${escapeHtml(r.days || '')}</td>
+            <td>${escapeHtml(r.status)}</td>
+          </tr>
+        `).join('');
+      } catch(e){ console.error(e); alerts.error(e?.message||e); }
+    }
+    async function init(){ if (!qs('#calendar-my-reservations')) return; await load(); }
+    document.addEventListener('action:ajaxify.end', init);
+    init();
+  }
+
+  if (typeof require === 'function'){
+    require(['api','alerts'], function(api, alerts){ boot(api, alerts); });
+  }
+})();

package/templates/admin/calendar-planning.tpl

@@ -33,3 +33,5 @@ require(['plugins/nodebb-plugin-calendar-onekite/static/js/admin-planning'], fun
   Mod.init && Mod.init();
 });
 </script>
+
+<script src="/plugins/nodebb-plugin-calendar-onekite/static/js/admin.bundle.js"></script>

package/templates/admin/plugins/calendar-onekite.tpl

@@ -77,3 +77,5 @@
 <script>
 require(['plugins/nodebb-plugin-calendar-onekite/static/js/admin'], function () {});
 </script>
+
+<script src="/plugins/nodebb-plugin-calendar-onekite/static/js/admin.bundle.js"></script>

package/templates/calendar-my-reservations.tpl

@@ -26,4 +26,6 @@ require(['plugins/nodebb-plugin-calendar-onekite/static/js/calendar-my-reservati
 });
 </script>
 
+<script src="/plugins/nodebb-plugin-calendar-onekite/static/js/my-reservations.bundle.js"></script>
+
 <!-- IMPORT partials/footer.tpl -->

package/templates/calendar.tpl

@@ -104,5 +104,6 @@ require(['plugins/nodebb-plugin-calendar-onekite/static/js/calendar'], function
   Calendar.init && Calendar.init();
 });
 </script>
+<script src="/plugins/nodebb-plugin-calendar-onekite/static/js/calendar.bundle.js"></script>
 
 <!-- IMPORT partials/footer.tpl -->