nodebb-plugin-calendar-onekite 2.1.2 → 2.2.0

package/library.js

@@ -1,9 +1,32 @@
 'use strict';
 
+/**
+ * NodeBB v4 plugin: Calendar OneKite
+ * - Events + booking items (with pickupLocation per item)
+ * - Multi-day reservations
+ * - Admin validation -> HelloAsso checkout link -> payment webhook -> mark paid
+ * - Admin planning view + "My reservations" page
+ * - Settings:
+ *   - Settings key: "calendar-onekite"
+ *   - Admin page: /admin/plugins/calendar-onekite
+ *   - Admin API:  /api/admin/plugins/calendar-onekite
+ *
+ * Templates expected:
+ * - templates/calendar.tpl
+ * - templates/calendar-my-reservations.tpl
+ * - templates/admin/plugins/calendar-onekite.tpl
+ * - templates/admin/calendar-planning.tpl
+ * - templates/widgets/calendar-upcoming.tpl
+ * - templates/emails/calendar-reservation-created.tpl
+ * - templates/emails/calendar-reservation-approved.tpl
+ * - templates/emails/calendar-payment-confirmed.tpl
+ */
+
 const db = require.main.require('./src/database');
 const user = require.main.require('./src/user');
 const meta = require.main.require('./src/meta');
 const emailer = require.main.require('./src/emailer');
+const winston = require.main.require('winston');
 
 const Settings = meta.settings;
 const helloAsso = require('./helloasso');
@@ -19,46 +42,26 @@ function getEventKey(eid) {
   return EVENT_KEY_PREFIX + eid;
 }
 
-function mountApiBoth(router, method, path, ...handlers) {
-  const m = String(method).toLowerCase();
-  router[m]('/api' + path, ...handlers);
-  router[m]('/api/v3' + path, ...handlers);
-}
-
-async function getParsedSettings() {
-  const s = (await Settings.get(SETTINGS_KEY)) || {};
-  const parseJson = (str, fallback) => {
-    try { return JSON.parse(str || ''); } catch { return fallback; }
-  };
-
-  const locations = parseJson(s.locationsJson, [
-    { id: 'arnaud', name: 'Chez Arnaud' },
-    { id: 'siege', name: 'Siège Onekite' },
-  ]);
-
-  const inventory = parseJson(s.inventoryJson, [
-    { id: 'wing', name: 'Aile Wing', price: 5, stockByLocation: { arnaud: 1, siege: 0 } },
-  ]);
-
-  return { ...s, locations, inventory };
-}
-
 async function nextReservationId() {
   const rid = await db.incrObjectField('global', 'nextCalendarRid');
   return String(rid);
 }
 
+// number of days between two yyyy-mm-dd dates (inclusive)
 function daysBetween(start, end) {
   const d1 = new Date(start);
   const d2 = new Date(end);
   if (isNaN(d1.getTime()) || isNaN(d2.getTime())) return 1;
+
   const t1 = Date.UTC(d1.getFullYear(), d1.getMonth(), d1.getDate());
   const t2 = Date.UTC(d2.getFullYear(), d2.getMonth(), d2.getDate());
   const diff = Math.round((t2 - t1) / (1000 * 60 * 60 * 24));
   return Math.max(1, diff + 1);
 }
 
-/* ---------------- Events ---------------- */
+/* -----------------------------
+ * Events
+ * ---------------------------- */
 
 async function createEvent(data, uid) {
   const eid = await db.incrObjectField('global', 'nextCalendarEid');
@@ -68,9 +71,7 @@ async function createEvent(data, uid) {
   const startTs = Number(new Date(data.start).getTime()) || now;
   const endTs = Number(new Date(data.end).getTime()) || startTs;
 
-  const bookingItemIds = Array.isArray(data.bookingItemIds)
-    ? data.bookingItemIds.map(String)
-    : [];
+  const bookingItems = Array.isArray(data.bookingItems) ? data.bookingItems : [];
 
   const eventObj = {
     eid: String(eid),
@@ -91,7 +92,7 @@ async function createEvent(data, uid) {
     visibility: String(data.visibility || 'public'),
 
     bookingEnabled: data.bookingEnabled ? 1 : 0,
-    bookingItems: JSON.stringify(bookingItemIds), // stores IDs only
+    bookingItems: JSON.stringify(bookingItems),
     reservations: JSON.stringify([]),
   };
 
@@ -112,18 +113,9 @@ async function updateEvent(eid, data) {
   const startTs = data.start ? new Date(data.start).getTime() : new Date(existing.start).getTime();
   const endTs = data.end ? new Date(data.end).getTime() : new Date(existing.end).getTime();
 
-  const existingIds = (() => {
-    try {
-      const arr = JSON.parse(existing.bookingItems || '[]');
-      return Array.isArray(arr) ? arr.map(String) : [];
-    } catch {
-      return [];
-    }
-  })();
-
-  const bookingItemIds = Array.isArray(data.bookingItemIds)
-    ? data.bookingItemIds.map(String)
-    : existingIds;
+  const bookingItems = Array.isArray(data.bookingItems)
+    ? data.bookingItems
+    : JSON.parse(existing.bookingItems || '[]');
 
   const updated = {
     ...existing,
@@ -135,7 +127,7 @@ async function updateEvent(eid, data) {
     location: data.location !== undefined ? String(data.location) : existing.location,
     visibility: data.visibility !== undefined ? String(data.visibility) : existing.visibility,
     bookingEnabled: data.bookingEnabled !== undefined ? (data.bookingEnabled ? 1 : 0) : (existing.bookingEnabled || 0),
-    bookingItems: JSON.stringify(bookingItemIds),
+    bookingItems: JSON.stringify(bookingItems),
     updatedAt: String(Date.now()),
   };
 
@@ -155,35 +147,46 @@ async function getEventsBetween(start, end) {
   const eids = await db.getSortedSetRangeByScore(EVENTS_SET_KEY, 0, -1, startTs, endTs);
   if (!eids || !eids.length) return [];
 
-  const keys = eids.map(id => getEventKey(id));
+  const keys = eids.map(eid => getEventKey(eid));
   const events = await db.getObjects(keys);
 
-  return (events || []).filter(Boolean);
+  return (events || []).filter(Boolean).map(ev => ({
+    ...ev,
+    bookingItems: JSON.parse(ev.bookingItems || '[]'),
+  }));
 }
 
 async function getUpcomingEvents(limit = 5) {
   const now = Date.now();
   const eids = await db.getSortedSetRangeByScore(EVENTS_SET_KEY, 0, limit - 1, now, '+inf');
   if (!eids || !eids.length) return [];
-  const keys = eids.map(id => getEventKey(id));
+
+  const keys = eids.map(eid => getEventKey(eid));
   const events = await db.getObjects(keys);
   return (events || []).filter(Boolean);
 }
 
-/* ---------------- Permissions ---------------- */
+/* -----------------------------
+ * Permissions
+ * ---------------------------- */
 
 async function userCanCreate(uid) {
   if (!uid || uid === 0) return false;
+
   const settings = await Settings.get(SETTINGS_KEY);
   if (!settings || !settings.allowedGroups) return false;
 
   const allowedSet = new Set(
-    settings.allowedGroups.split(',').map(g => g.trim().toLowerCase()).filter(Boolean)
+    settings.allowedGroups
+      .split(',')
+      .map(g => g.trim().toLowerCase())
+      .filter(Boolean)
   );
   if (!allowedSet.size) return false;
 
   const userGroupsArr = await user.getUserGroups([uid]);
   const groups = (userGroupsArr[0] || []).map(g => (g.name || '').toLowerCase());
+
   return groups.some(g => allowedSet.has(g));
 }
 
@@ -191,19 +194,26 @@ async function userCanBook(uid) {
   if (!uid || uid === 0) return false;
 
   const settings = await Settings.get(SETTINGS_KEY);
+  // if not configured -> allow any logged-in user
   if (!settings || !settings.allowedBookingGroups) return true;
 
   const allowedSet = new Set(
-    settings.allowedBookingGroups.split(',').map(g => g.trim().toLowerCase()).filter(Boolean)
+    settings.allowedBookingGroups
+      .split(',')
+      .map(g => g.trim().toLowerCase())
+      .filter(Boolean)
   );
   if (!allowedSet.size) return true;
 
   const userGroupsArr = await user.getUserGroups([uid]);
   const groups = (userGroupsArr[0] || []).map(g => (g.name || '').toLowerCase());
+
   return groups.some(g => allowedSet.has(g));
 }
 
-/* ---------------- RSVP ---------------- */
+/* -----------------------------
+ * RSVP
+ * ---------------------------- */
 
 async function setRsvp(eid, uid, status) {
   const key = getEventKey(eid);
@@ -211,7 +221,7 @@ async function setRsvp(eid, uid, status) {
   if (!event) throw new Error('Event not found');
 
   const parseList = (str) => {
-    try { return JSON.parse(str || '[]'); } catch { return []; }
+    try { return JSON.parse(str || '[]'); } catch (e) { return []; }
   };
 
   let yes = parseList(event.rsvpYes);
@@ -239,608 +249,610 @@ async function setRsvp(eid, uid, status) {
   return updated;
 }
 
-/* ---------------- Reservations data helpers ---------------- */
-
-async function getAllReservations() {
-  const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
-  const out = [];
-  for (const eid of eids) {
-    const ev = await getEvent(eid);
-    if (!ev) continue;
-    const resList = (() => {
-      try { return JSON.parse(ev.reservations || '[]'); } catch { return []; }
-    })();
-    for (const r of resList) {
-      out.push({ event: ev, reservation: r });
-    }
-  }
-  return out;
-}
+/* -----------------------------
+ * Pricing
+ * ---------------------------- */
 
-/* ---------------- Pricing ---------------- */
+function computePrice(event, reservation) {
+  const items = JSON.parse(event.bookingItems || '[]');
+  const item = items.find(i => i.id === reservation.itemId);
+  if (!item) return 0;
 
-function computePrice(inventoryItem, reservation) {
-  const unit = Number(inventoryItem?.price || 0);
+  const unit = Number(item.price || 0);
   const days = Number(reservation.days || 1);
   return unit * Number(reservation.quantity || 0) * days;
 }
 
-/* ---------------- Renderers ---------------- */
-
-function renderCalendarPage(req, res) { res.render('calendar', { title: 'Calendrier' }); }
-function renderMyReservationsPage(req, res) { res.render('calendar-my-reservations', { title: 'Mes réservations' }); }
-function renderPlanningPage(req, res) { res.render('admin/calendar-planning', { title: 'Planning' }); }
-
-async function renderAdminPage(req, res) {
-  try {
-    const settings = (await Settings.get(SETTINGS_KEY)) || {};
-    // Provide defaults JSON strings if empty
-    if (!settings.locationsJson) {
-      settings.locationsJson = JSON.stringify([
-        { id: 'arnaud', name: 'Chez Arnaud' },
-        { id: 'siege', name: 'Siège Onekite' },
-      ], null, 2);
-    }
-    if (!settings.inventoryJson) {
-      settings.inventoryJson = JSON.stringify([
-        { id: 'wing', name: 'Aile Wing', price: 5, stockByLocation: { arnaud: 1, siege: 0 } },
-      ], null, 2);
-    }
+/* -----------------------------
+ * Renderers (pages)
+ * ---------------------------- */
 
-    res.render('admin/plugins/calendar-onekite', { title: 'Calendar OneKite', settings });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
+function renderCalendarPage(req, res) {
+  res.render('calendar', { title: 'Calendrier' });
 }
 
-/* ---------------- Admin APIs ---------------- */
+function renderMyReservationsPage(req, res) {
+  res.render('calendar-my-reservations', { title: 'Mes réservations' });
+}
 
-async function adminGetPending(req, res) {
-  try {
-    const result = [];
-    const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
-    for (const eid of eids) {
-      const event = await getEvent(eid);
-      if (!event) continue;
-      const reservations = JSON.parse(event.reservations || '[]');
-      const pending = reservations.filter(r => r.status === 'pending_admin');
-      if (pending.length) result.push({ event, reservations: pending });
-    }
-    res.json(result);
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
+function renderPlanningPage(req, res) {
+  res.render('admin/calendar-planning', { title: 'Planning des réservations' });
 }
 
-async function adminSaveSettings(req, res) {
+async function renderAdminPage(req, res) {
   try {
-    await Settings.set(SETTINGS_KEY, req.body);
-    res.json({ status: 'ok' });
+    const settings = (await Settings.get(SETTINGS_KEY)) || {};
+    res.render('admin/plugins/calendar-onekite', {
+      title: 'Calendar OneKite',
+      settings,
+    });
   } catch (err) {
+    if (req.path && req.path.startsWith('/api/')) {
+      return winston.error(`[calendar-onekite] ${err.stack || err.message}`);
     res.status(500).json({ error: err.message });
+    }
+    res.status(500).send(err.message);
   }
 }
 
-async function adminValidateReservation(req, res) {
-  try {
-    const rid = req.params.rid;
-    const all = await getAllReservations();
-
-    let target = null;
-    for (const row of all) {
-      if (String(row.reservation.rid) === String(rid)) { target = row; break; }
-    }
-    if (!target) return res.status(404).json({ error: 'Réservation introuvable' });
+/* -----------------------------
+ * Plugin init
+ * ---------------------------- */
 
-    const { event } = target;
-    const reservation = target.reservation;
+Plugin.init = async function (params) {
+  const { router, middleware } = params;
+  appRef = params.app;
 
-    if (reservation.status !== 'pending_admin') return res.status(400).json({ error: 'Réservation déjà traitée' });
+  // Public pages
+  router.get('/calendar', middleware.buildHeader, renderCalendarPage);
+  router.get('/api/calendar', renderCalendarPage);
 
-    reservation.status = 'awaiting_payment';
+  router.get('/calendar/my-reservations', middleware.buildHeader, renderMyReservationsPage);
+  router.get('/api/calendar/my-reservations/page', renderMyReservationsPage);
 
-    const resList = JSON.parse(event.reservations || '[]');
-    const idx = resList.findIndex(r => String(r.rid) === String(rid));
-    resList[idx] = reservation;
-    event.reservations = JSON.stringify(resList);
-    await db.setObject(getEventKey(event.eid), event);
+  // Admin planning page
+  router.get('/admin/calendar/planning', middleware.admin.buildHeader, renderPlanningPage);
+  router.get('/api/admin/calendar/planning/page', renderPlanningPage);
 
-    const settings = await getParsedSettings();
-    const invItem = settings.inventory.find(i => String(i.id) === String(reservation.itemId));
-    const amount = computePrice(invItem, reservation);
+  /* -----------------------------
+   * Events API
+   * ---------------------------- */
 
-    const checkoutUrl = await helloAsso.createHelloAssoCheckoutIntent({
-      eid: reservation.eid,
-      rid,
-      uid: reservation.uid,
-      itemId: reservation.itemId,
-      quantity: reservation.quantity,
-      amount,
-    });
+  router.get('/api/calendar/events', async (req, res) => {
+    try {
+      const { start, end } = req.query;
+      if (!start || !end) return res.status(400).json({ error: 'Missing start/end' });
+      const events = await getEventsBetween(start, end);
+      res.json(events);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 
+  router.post('/api/calendar/event', middleware.ensureLoggedIn, async (req, res) => {
     try {
-      await emailer.send('calendar-reservation-approved', reservation.uid, {
-        subject: 'Votre réservation a été validée',
-        eventTitle: event.title,
-        itemName: invItem?.name || reservation.itemId,
-        quantity: reservation.quantity,
-        checkoutUrl,
-        pickupLocation: reservation.pickupLocationName || reservation.locationId || 'Non précisé',
-        dateStart: reservation.dateStart,
-        dateEnd: reservation.dateEnd,
-        days: reservation.days || 1,
-      });
-    } catch (e) {
-      console.warn('[calendar-onekite] email reservation-approved error:', e.message);
+      const uid = req.user?.uid || 0;
+      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
+      const event = await createEvent(req.body, uid);
+      res.json(event);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
     }
+  });
 
-    res.json({ success: true, checkoutUrl });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
+  router.put('/api/calendar/event/:eid', middleware.ensureLoggedIn, async (req, res) => {
+    try {
+      const uid = req.user?.uid || 0;
+      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
+      const eid = req.params.eid;
+      const event = await updateEvent(eid, req.body);
+      res.json(event);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 
-async function adminCancelReservation(req, res) {
-  try {
-    const rid = req.params.rid;
-    const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
-    let found = false;
+  router.delete('/api/calendar/event/:eid', middleware.ensureLoggedIn, async (req, res) => {
+    try {
+      const uid = req.user?.uid || 0;
+      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
+      const eid = req.params.eid;
+      await deleteEvent(eid);
+      res.json({ status: 'ok' });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 
-    for (const eid of eids) {
+  router.get('/api/calendar/event/:eid', async (req, res) => {
+    try {
+      const eid = req.params.eid;
       const event = await getEvent(eid);
-      if (!event) continue;
+      if (!event) return res.status(404).json({ error: 'Événement introuvable' });
+      const items = JSON.parse(event.bookingItems || '[]');
       const reservations = JSON.parse(event.reservations || '[]');
-      const idx = reservations.findIndex(r => String(r.rid) === String(rid));
-      if (idx !== -1) {
-        reservations[idx].status = 'cancelled';
-        event.reservations = JSON.stringify(reservations);
-        await db.setObject(getEventKey(event.eid), event);
-        found = true;
-        break;
-      }
+      res.json({ ...event, bookingItems: items, reservations });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
     }
+  });
 
-    if (!found) return res.status(404).json({ error: 'Réservation introuvable' });
-    res.json({ success: true });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
+  /* -----------------------------
+   * RSVP
+   * ---------------------------- */
 
-async function adminGetPlanning(req, res) {
-  try {
-    const settings = await getParsedSettings();
-    const locMap = new Map(settings.locations.map(l => [String(l.id), l.name || l.id]));
-    const invMap = new Map(settings.inventory.map(i => [String(i.id), i.name || i.id]));
-
-    const all = await getAllReservations();
-    const rows = [];
-
-    for (const row of all) {
-      const event = row.event;
-      const r = row.reservation;
-      if (!r) continue;
-      if (!['pending_admin', 'awaiting_payment', 'paid'].includes(String(r.status))) continue;
-
-      rows.push({
-        rid: r.rid,
-        eid: event.eid,
-        eventTitle: event.title,
-        itemId: r.itemId,
-        itemName: invMap.get(String(r.itemId)) || r.itemId,
-        uid: r.uid,
-        quantity: r.quantity,
-        dateStart: r.dateStart,
-        dateEnd: r.dateEnd,
-        days: r.days || daysBetween(r.dateStart, r.dateEnd),
-        status: r.status,
-        locationId: r.locationId,
-        pickupLocation: r.pickupLocationName || locMap.get(String(r.locationId)) || 'Non précisé',
-      });
+  router.post('/api/calendar/event/:eid/rsvp', middleware.ensureLoggedIn, async (req, res) => {
+    try {
+      const eid = req.params.eid;
+      const uid = req.user?.uid || 0;
+      const status = req.body.status;
+      const event = await setRsvp(eid, uid, status);
+      res.json(event);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
     }
+  });
 
-    rows.sort((a, b) => new Date(a.dateStart) - new Date(b.dateStart));
-    res.json(rows);
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
+  /* -----------------------------
+   * Client permissions endpoints
+   * ---------------------------- */
 
-/* ---------------- Public APIs ---------------- */
+  router.get('/api/calendar/permissions/create', async (req, res) => {
+    const uid = req.user?.uid || 0;
+    const allow = await userCanCreate(uid);
+    res.json({ allow });
+  });
 
-async function inventoryApi(req, res) {
-  try {
-    const settings = await getParsedSettings();
-    res.json({
-      locations: settings.locations || [],
-      inventory: settings.inventory || [],
-    });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
+  router.get('/api/calendar/permissions/book', async (req, res) => {
+    const uid = req.user?.uid || 0;
+    const allow = await userCanBook(uid);
+    res.json({ allow });
+  });
 
-async function myReservations(req, res) {
-  try {
-    const uid = String(req.user?.uid || 0);
-    if (!uid || uid === '0') return res.status(403).json({ error: 'Non connecté' });
+  /* -----------------------------
+   * Multi-day reservation request
+   * ---------------------------- */
 
-    const settings = await getParsedSettings();
-    const locMap = new Map(settings.locations.map(l => [String(l.id), l.name || l.id]));
-    const invMap = new Map(settings.inventory.map(i => [String(i.id), i.name || i.id]));
+  router.post('/api/calendar/event/:eid/book', middleware.ensureLoggedIn, async (req, res) => {
+    try {
+      const uid = req.user?.uid || 0;
+      const eid = req.params.eid;
+      const { itemId, quantity, dateStart, dateEnd } = req.body;
 
-    const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
-    const result = [];
+      if (!await userCanBook(uid)) {
+        return res.status(403).json({ error: 'Vous n’êtes pas autorisé à réserver du matériel.' });
+      }
+      if (!dateStart || !dateEnd) {
+        return res.status(400).json({ error: 'Dates de début et de fin obligatoires.' });
+      }
+      if (String(dateEnd) < String(dateStart)) {
+        return res.status(400).json({ error: 'La date de fin doit être ≥ la date de début.' });
+      }
 
-    for (const eid of eids) {
       const event = await getEvent(eid);
-      if (!event) continue;
-
-      const reservations = JSON.parse(event.reservations || '[]');
-      reservations
-        .filter(r => String(r.uid) === uid)
-        .forEach(r => {
-          result.push({
-            ...r,
-            eventTitle: event.title,
-            itemName: invMap.get(String(r.itemId)) || r.itemId,
-            pickupLocation: r.pickupLocationName || locMap.get(String(r.locationId)) || '',
-          });
-        });
-    }
-
-    result.sort((a, b) => new Date(a.dateStart) - new Date(b.dateStart));
-    res.json(result);
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
-
-async function bookReservation(req, res) {
-  try {
-    const uid = req.user?.uid || 0;
-    const eid = req.params.eid;
-    const { itemId, quantity, dateStart, dateEnd, locationId } = req.body;
-
-    if (!await userCanBook(uid)) {
-      return res.status(403).json({ error: 'Vous n’êtes pas autorisé à réserver du matériel.' });
-    }
-    if (!dateStart || !dateEnd || !itemId || !locationId) {
-      return res.status(400).json({ error: 'itemId, locationId, dateStart, dateEnd obligatoires.' });
-    }
-    if (String(dateEnd) < String(dateStart)) {
-      return res.status(400).json({ error: 'La date de fin doit être ≥ la date de début.' });
-    }
-
-    const settings = await getParsedSettings();
-    const loc = settings.locations.find(l => String(l.id) === String(locationId));
-    if (!loc) return res.status(400).json({ error: 'Lieu invalide.' });
+      if (!event) return res.status(404).json({ error: 'Événement introuvable' });
+      if (!Number(event.bookingEnabled)) return res.status(400).json({ error: 'Réservation désactivée' });
 
-    const invItem = settings.inventory.find(i => String(i.id) === String(itemId));
-    if (!invItem) return res.status(400).json({ error: 'Matériel invalide.' });
+      const items = JSON.parse(event.bookingItems || '[]');
+      const item = items.find(i => i.id === itemId);
+      if (!item) return res.status(400).json({ error: 'Matériel introuvable' });
 
-    const stockTotal = Number(invItem.stockByLocation?.[String(locationId)] || 0);
-    if (stockTotal <= 0) return res.status(400).json({ error: 'Stock indisponible sur ce lieu.' });
+      const q = Number(quantity);
+      if (!q || q <= 0) return res.status(400).json({ error: 'Quantité invalide' });
 
-    const q = Number(quantity);
-    if (!q || q <= 0) return res.status(400).json({ error: 'Quantité invalide' });
+      const allRes = JSON.parse(event.reservations || '[]');
 
-    const event = await getEvent(eid);
-    if (!event) return res.status(404).json({ error: 'Événement introuvable' });
-    if (!Number(event.bookingEnabled)) return res.status(400).json({ error: 'Réservation désactivée' });
+      // Stock check: sum overlapping reservations (pending_admin/awaiting_payment/paid) for the same item
+      const overlapping = allRes.filter(r => {
+        if (r.itemId !== itemId) return false;
+        if (r.status === 'cancelled') return false;
 
-    // Ensure item is allowed for this event
-    const allowedIds = (() => {
-      try {
-        const arr = JSON.parse(event.bookingItems || '[]');
-        return Array.isArray(arr) ? arr.map(String) : [];
-      } catch {
-        return [];
-      }
-    })();
-    if (!allowedIds.includes(String(itemId))) {
-      return res.status(400).json({ error: 'Ce matériel n’est pas autorisé pour cet événement.' });
-    }
-
-    // Global availability: check overlaps across all events reservations (same itemId + locationId)
-    const all = await getAllReservations();
-    const overlapping = all
-      .map(x => x.reservation)
-      .filter(r => r && String(r.itemId) === String(itemId))
-      .filter(r => String(r.locationId) === String(locationId))
-      .filter(r => String(r.status) !== 'cancelled')
-      .filter(r => {
         const startR = new Date(r.dateStart);
         const endR = new Date(r.dateEnd);
         const startN = new Date(dateStart);
         const endN = new Date(dateEnd);
+
         return !(endN < startR || startN > endR);
       });
 
-    const used = overlapping.reduce((sum, r) => sum + Number(r.quantity || 0), 0);
-    const available = stockTotal - used;
-    if (q > available) return res.status(400).json({ error: `Stock insuffisant sur ce lieu (dispo: ${available}).` });
-
-    const rid = await nextReservationId();
-    const nbDays = daysBetween(dateStart, dateEnd);
-
-    const reservation = {
-      rid,
-      eid: String(eid),
-      uid: String(uid),
-      itemId: String(itemId),
-      locationId: String(locationId),
-      pickupLocationName: String(loc.name || loc.id),
-      quantity: q,
-      dateStart,
-      dateEnd,
-      days: nbDays,
-      status: 'pending_admin',
-      helloAssoOrderId: null,
-      createdAt: Date.now(),
-    };
-
-    const resList = JSON.parse(event.reservations || '[]');
-    resList.push(reservation);
-    event.reservations = JSON.stringify(resList);
-    await db.setObject(getEventKey(eid), event);
+      const used = overlapping.reduce((sum, r) => sum + Number(r.quantity || 0), 0);
+      const available = Number(item.total || 0) - used;
+      if (q > available) return res.status(400).json({ error: 'Matériel indisponible pour ces dates.' });
 
-    try {
-      await emailer.send('calendar-reservation-created', uid, {
-        subject: 'Votre demande de réservation a été envoyée',
-        eventTitle: event.title,
-        item: invItem.name || invItem.id,
-        quantity: reservation.quantity,
+      const rid = await nextReservationId();
+      const now = Date.now();
+      const nbDays = daysBetween(dateStart, dateEnd);
+
+      const reservation = {
+        rid,
+        eid: String(eid),
+        uid: String(uid),
+        itemId: String(itemId),
+        quantity: q,
         dateStart,
         dateEnd,
         days: nbDays,
-        pickupLocation: reservation.pickupLocationName,
+        status: 'pending_admin',
+        helloAssoOrderId: null,
+        createdAt: now,
+        pickupLocation: String(item.pickupLocation || ''),
+      };
+
+      allRes.push(reservation);
+      event.bookingItems = JSON.stringify(items);
+      event.reservations = JSON.stringify(allRes);
+
+      await db.setObject(getEventKey(eid), event);
+
+      // Email: request created
+      try {
+        await emailer.send('calendar-reservation-created', uid, {
+          subject: 'Votre demande de réservation a été envoyée',
+          eventTitle: event.title,
+          item: item.name,
+          quantity: reservation.quantity,
+          date: new Date().toLocaleString('fr-FR'),
+          dateStart,
+          dateEnd,
+          days: nbDays,
+          pickupLocation: reservation.pickupLocation || 'Non précisé',
+        });
+      } catch (e) {
+        console.warn('[calendar-onekite] email reservation-created error:', e.message);
+      }
+
+      res.json({
+        success: true,
+        status: 'pending_admin',
+        message: 'Votre demande de réservation a été envoyée. Elle doit être validée par un administrateur.',
       });
-    } catch (e) {
-      console.warn('[calendar-onekite] email reservation-created error:', e.message);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
     }
+  });
 
-    res.json({
-      success: true,
-      status: 'pending_admin',
-      message: 'Votre demande de réservation a été envoyée. Elle doit être validée par un administrateur.',
-    });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-}
+  /* -----------------------------
+   * Admin: pending list
+   * ---------------------------- */
 
-/* ---------------- HelloAsso webhook ---------------- */
+  router.get('/api/admin/calendar/pending', middleware.admin.checkPrivileges, async (req, res) => {
+    try {
+      const result = [];
+      const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
 
-async function helloAssoWebhook(req, res) {
-  try {
-    const payload = req.body;
-    const order = payload.order || payload;
+      for (const eid of eids) {
+        const event = await getEvent(eid);
+        if (!event) continue;
 
-    const orderId = String(order.id || '');
-    const state = order.state || order.status || '';
-    if (state !== 'Paid') return res.json({ ignored: true });
+        const reservations = JSON.parse(event.reservations || '[]');
+        const pending = reservations.filter(r => r.status === 'pending_admin');
+        if (pending.length) result.push({ event, reservations: pending });
+      }
 
-    const custom = order.metadata || order.customFields || {};
-    const eid = String(custom.eid || '');
-    const rid = String(custom.rid || '');
-    if (!eid || !rid) return res.status(400).json({ error: 'Missing eid/rid in metadata' });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 
-    const event = await getEvent(eid);
-    if (!event) throw new Error('Event not found');
+  /* -----------------------------
+   * Admin: validate reservation -> awaiting_payment + HelloAsso checkout
+   * ---------------------------- */
 
-    const reservations = JSON.parse(event.reservations || '[]');
-    const idx = reservations.findIndex(r => String(r.rid) === String(rid));
-    if (idx === -1) throw new Error('Reservation not found');
+  router.post('/api/admin/calendar/reservation/:rid/validate', middleware.admin.checkPrivileges, async (req, res) => {
+    try {
+      const rid = req.params.rid;
+      const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
+
+      let targetEvent = null;
+      let reservation = null;
+
+      for (const eid of eids) {
+        const event = await getEvent(eid);
+        if (!event) continue;
+
+        const reservations = JSON.parse(event.reservations || '[]');
+        const r = reservations.find(rr => rr.rid === rid);
+        if (r) {
+          targetEvent = event;
+          reservation = r;
+          break;
+        }
+      }
 
-    const reservation = reservations[idx];
-    if (reservation.status === 'paid') return res.json({ ok: true });
+      if (!reservation) return res.status(404).json({ error: 'Réservation introuvable' });
+      if (reservation.status !== 'pending_admin') return res.status(400).json({ error: 'Réservation déjà traitée' });
 
-    reservation.status = 'paid';
-    reservation.helloAssoOrderId = orderId;
-    reservations[idx] = reservation;
+      reservation.status = 'awaiting_payment';
 
-    event.reservations = JSON.stringify(reservations);
-    await db.setObject(getEventKey(eid), event);
+      const resList = JSON.parse(targetEvent.reservations || '[]');
+      const idx = resList.findIndex(r => r.rid === rid);
+      resList[idx] = reservation;
+      targetEvent.reservations = JSON.stringify(resList);
 
-    const settings = await getParsedSettings();
-    const invItem = settings.inventory.find(i => String(i.id) === String(reservation.itemId));
+      await db.setObject(getEventKey(targetEvent.eid), targetEvent);
 
-    try {
-      await emailer.send('calendar-payment-confirmed', reservation.uid, {
-        subject: 'Votre paiement a été confirmé',
-        eventTitle: event.title,
-        itemName: invItem?.name || reservation.itemId,
+      const amount = computePrice(targetEvent, reservation);
+      const checkoutUrl = await helloAsso.createHelloAssoCheckoutIntent({
+        eid: reservation.eid,
+        rid,
+        uid: reservation.uid,
+        itemId: reservation.itemId,
         quantity: reservation.quantity,
-        pickupLocation: reservation.pickupLocationName || reservation.locationId || 'Non précisé',
-        dateStart: reservation.dateStart,
-        dateEnd: reservation.dateEnd,
-        days: reservation.days || 1,
+        amount,
       });
-    } catch (e) {
-      console.warn('[calendar-onekite] email payment-confirmed error:', e.message);
-    }
-
-    res.json({ ok: true });
-  } catch (err) {
-    console.error('[calendar-onekite] HelloAsso webhook error:', err);
-    res.status(500).json({ error: err.message });
-  }
-}
 
-/* ---------------- Widget ---------------- */
+      try {
+        await emailer.send('calendar-reservation-approved', reservation.uid, {
+          subject: 'Votre réservation a été validée',
+          eventTitle: targetEvent.title,
+          itemName: reservation.itemId,
+          quantity: reservation.quantity,
+          checkoutUrl,
+          pickupLocation: reservation.pickupLocation || 'Non précisé',
+          dateStart: reservation.dateStart,
+          dateEnd: reservation.dateEnd,
+          days: reservation.days || 1,
+        });
+      } catch (e) {
+        console.warn('[calendar-onekite] email reservation-approved error:', e.message);
+      }
 
-Plugin.defineWidgets = async function (widgets) {
-  widgets.push({
-    widget: 'calendarUpcoming',
-    name: 'Prochains événements',
-    description: 'Affiche la liste des prochains événements du calendrier.',
-    content: '',
+      res.json({ success: true, checkoutUrl });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
   });
-  return widgets;
-};
 
-Plugin.renderUpcomingWidget = async function (widget, callback) {
-  try {
-    const settings = (await Settings.get(SETTINGS_KEY)) || {};
-    const limit = Number(widget?.data?.limit || settings.limit || 5);
-    const events = await getUpcomingEvents(limit);
-    const html = await appRef.renderAsync('widgets/calendar-upcoming', { events });
-    widget.html = html;
+  /* -----------------------------
+   * Admin: cancel reservation
+   * ---------------------------- */
 
-    if (typeof callback === 'function') return callback(null, widget);
-    return widget;
-  } catch (err) {
-    if (typeof callback === 'function') return callback(err);
-    throw err;
-  }
-};
+  router.post('/api/admin/calendar/reservation/:rid/cancel', middleware.admin.checkPrivileges, async (req, res) => {
+    try {
+      const rid = req.params.rid;
+      const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
+
+      let found = false;
+
+      for (const eid of eids) {
+        const event = await getEvent(eid);
+        if (!event) continue;
+
+        const reservations = JSON.parse(event.reservations || '[]');
+        const rIndex = reservations.findIndex(rr => rr.rid === rid);
+        if (rIndex !== -1) {
+          reservations[rIndex].status = 'cancelled';
+          event.reservations = JSON.stringify(reservations);
+          await db.setObject(getEventKey(event.eid), event);
+          found = true;
+          break;
+        }
+      }
 
-Plugin.addAdminNavigation = function (header) {
-  header.plugins.push({
-    route: '/plugins/calendar-onekite',
-    icon: 'fa fa-calendar',
-    name: 'Calendar OneKite',
+      if (!found) return res.status(404).json({ error: 'Réservation introuvable' });
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
   });
-  return header;
-};
 
-/* ---------------- Init ---------------- */
+  /* -----------------------------
+   * HelloAsso webhook (marks reservation paid)
+   * ---------------------------- */
 
-Plugin.init = async function (params) {
-  const { router, middleware } = params;
-  appRef = params.app;
+  router.post('/api/calendar/helloasso/webhook', async (req, res) => {
+    try {
+      const payload = req.body;
+      const order = payload.order || payload;
 
-  // Pages
-  router.get('/calendar', middleware.buildHeader, (req, res) => res.render('calendar', { title: 'Calendrier' }));
-  router.get('/calendar/my-reservations', middleware.buildHeader, (req, res) => res.render('calendar-my-reservations', { title: 'Mes réservations' }));
+      const orderId = String(order.id || '');
+      const state = order.state || order.status || '';
+      if (state !== 'Paid') return res.json({ ignored: true });
 
-  router.get('/admin/calendar/planning', middleware.admin.buildHeader, (req, res) => res.render('admin/calendar-planning', { title: 'Planning' }));
-  router.get('/admin/plugins/calendar-onekite', middleware.admin.buildHeader, renderAdminPage);
+      const custom = order.customFields || {};
+      const eid = String(custom.eid || '');
+      const rid = String(custom.rid || '');
 
-  // Admin page (ajaxify)
-  mountApiBoth(router, 'get', '/admin/plugins/calendar-onekite', middleware.admin.checkPrivileges, renderAdminPage);
+      if (!eid || !rid) return res.status(400).json({ error: 'Missing eid/rid in customFields' });
 
-  // Settings save
-  mountApiBoth(router, 'put', '/admin/plugins/calendar-onekite', middleware.admin.checkPrivileges, adminSaveSettings);
+      const event = await getEvent(eid);
+      if (!event) throw new Error('Event not found');
+
+      let reservations = JSON.parse(event.reservations || '[]');
+      const rIndex = reservations.findIndex(r => r.rid === rid);
+      if (rIndex === -1) throw new Error('Reservation not found');
+
+      const reservation = reservations[rIndex];
+      if (reservation.status === 'paid') return res.json({ ok: true });
+
+      // Update optional aggregate reserved count
+      const items = JSON.parse(event.bookingItems || '[]');
+      const itemIndex = items.findIndex(i => i.id === reservation.itemId);
+      if (itemIndex !== -1) {
+        const it = items[itemIndex];
+        it.reserved = (Number(it.reserved || 0) + Number(reservation.quantity || 0));
+        items[itemIndex] = it;
+      }
 
-  // Admin APIs
-  mountApiBoth(router, 'get', '/admin/calendar/pending', middleware.admin.checkPrivileges, adminGetPending);
-  mountApiBoth(router, 'post', '/admin/calendar/reservation/:rid/validate', middleware.admin.checkPrivileges, adminValidateReservation);
-  mountApiBoth(router, 'post', '/admin/calendar/reservation/:rid/cancel', middleware.admin.checkPrivileges, adminCancelReservation);
-  mountApiBoth(router, 'get', '/admin/calendar/planning', middleware.admin.checkPrivileges, adminGetPlanning);
+      reservation.status = 'paid';
+      reservation.helloAssoOrderId = orderId;
+      reservations[rIndex] = reservation;
 
-  // Public inventory
-  mountApiBoth(router, 'get', '/calendar/inventory', inventoryApi);
+      event.bookingItems = JSON.stringify(items);
+      event.reservations = JSON.stringify(reservations);
 
-  // Events list for FullCalendar
-  mountApiBoth(router, 'get', '/calendar/events', async (req, res) => {
-    try {
-      const { start, end } = req.query;
-      if (!start || !end) return res.status(400).json({ error: 'Missing start/end' });
-      const events = await getEventsBetween(start, end);
-      res.json(events);
-    } catch (err) {
-      res.status(500).json({ error: err.message });
-    }
-  });
+      await db.setObject(getEventKey(eid), event);
 
-  // Event CRUD
-  mountApiBoth(router, 'post', '/calendar/event', middleware.ensureLoggedIn, async (req, res) => {
-    try {
-      const uid = req.user?.uid || 0;
-      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
-      const event = await createEvent(req.body, uid);
-      res.json(event);
-    } catch (err) {
-      res.status(500).json({ error: err.message });
-    }
-  });
+      try {
+        await emailer.send('calendar-payment-confirmed', reservation.uid, {
+          subject: 'Votre paiement a été confirmé',
+          eventTitle: event.title,
+          itemName: reservation.itemId,
+          quantity: reservation.quantity,
+          pickupLocation: reservation.pickupLocation || 'Non précisé',
+          dateStart: reservation.dateStart,
+          dateEnd: reservation.dateEnd,
+          days: reservation.days || 1,
+        });
+      } catch (e) {
+        console.warn('[calendar-onekite] email payment-confirmed error:', e.message);
+      }
 
-  mountApiBoth(router, 'put', '/calendar/event/:eid', middleware.ensureLoggedIn, async (req, res) => {
-    try {
-      const uid = req.user?.uid || 0;
-      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
-      const event = await updateEvent(req.params.eid, req.body);
-      res.json(event);
+      res.json({ ok: true });
     } catch (err) {
+      console.error('[calendar-onekite] HelloAsso webhook error:', err);
       res.status(500).json({ error: err.message });
     }
   });
 
-  mountApiBoth(router, 'delete', '/calendar/event/:eid', middleware.ensureLoggedIn, async (req, res) => {
+  /* -----------------------------
+   * Admin plugin page + settings API
+   * IMPORTANT: keep these routes EXACTLY aligned with your admin.js
+   * ---------------------------- */
+
+  router.get('/admin/plugins/calendar-onekite', middleware.admin.buildHeader, renderAdminPage);
+  router.get('/api/admin/plugins/calendar-onekite', renderAdminPage);
+
+  router.put('/api/admin/plugins/calendar-onekite', middleware.admin.checkPrivileges, async (req, res) => {
     try {
-      const uid = req.user?.uid || 0;
-      if (!await userCanCreate(uid)) return res.status(403).json({ error: 'Permission refusée' });
-      await deleteEvent(req.params.eid);
+      await Settings.set(SETTINGS_KEY, req.body);
       res.json({ status: 'ok' });
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
   });
 
-  // Event details: enrich with bookingItemIds + resolved items
-  mountApiBoth(router, 'get', '/calendar/event/:eid', async (req, res) => {
-    try {
-      const settings = await getParsedSettings();
-      const invMap = new Map(settings.inventory.map(i => [String(i.id), i]));
+  /* -----------------------------
+   * My reservations API
+   * ---------------------------- */
 
-      const event = await getEvent(req.params.eid);
-      if (!event) return res.status(404).json({ error: 'Événement introuvable' });
-
-      const bookingItemIds = (() => {
-        try {
-          const arr = JSON.parse(event.bookingItems || '[]');
-          return Array.isArray(arr) ? arr.map(String) : [];
-        } catch { return []; }
-      })();
-
-      const bookingItems = bookingItemIds.map(id => invMap.get(String(id))).filter(Boolean);
-
-      const reservations = (() => {
-        try { return JSON.parse(event.reservations || '[]'); } catch { return []; }
-      })();
+  router.get('/api/calendar/my-reservations', middleware.ensureLoggedIn, async (req, res) => {
+    try {
+      const uid = String(req.user?.uid || 0);
+      if (!uid || uid === '0') return res.status(403).json({ error: 'Non connecté' });
+
+      const eids = await db.getSortedSetRange(EVENTS_SET_KEY, 0, -1);
+      const result = [];
+
+      for (const eid of eids) {
+        const event = await getEvent(eid);
+        if (!event) continue;
+
+        const items = JSON.parse(event.bookingItems || '[]');
+        const reservations = JSON.parse(event.reservations || '[]');
+
+        reservations
+          .filter(r => String(r.uid) === uid)
+          .forEach(r => {
+            const item = items.find(i => i.id === r.itemId);
+            result.push({
+              ...r,
+              eventTitle: event.title,
+              eventStart: event.start,
+              eventEnd: event.end,
+              itemName: item ? item.name : r.itemId,
+            });
+          });
+      }
 
-      res.json({ ...event, bookingItemIds, bookingItems, reservations });
+      result.sort((a, b) => new Date(a.dateStart) - new Date(b.dateStart));
+      res.json(result);
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
   });
 
-  // RSVP
-  mountApiBoth(router, 'post', '/calendar/event/:eid/rsvp', middleware.ensureLoggedIn, async (req, res) => {
+  /* -----------------------------
+   * Admin planning API (future reservations)
+   * ---------------------------- */
+
+  router.get('/api/admin/calendar/planning', middleware.admin.checkPrivileges, async (req, res) => {
     try {
-      const uid = req.user?.uid || 0;
-      const status = req.body.status;
-      const updated = await setRsvp(req.params.eid, uid, status);
-      res.json(updated);
+      const now = new Date();
+      const eids = await db.getSortedSetRangeByScore(EVENTS_SET_KEY, 0, -1, now.getTime(), '+inf');
+      const rows = [];
+
+      for (const eid of eids) {
+        const event = await getEvent(eid);
+        if (!event) continue;
+
+        const items = JSON.parse(event.bookingItems || '[]');
+        const reservations = JSON.parse(event.reservations || '[]');
+
+        reservations
+          .filter(r => r.status === 'pending_admin' || r.status === 'awaiting_payment' || r.status === 'paid')
+          .forEach(r => {
+            const item = items.find(i => i.id === r.itemId);
+            rows.push({
+              eid: event.eid,
+              eventTitle: event.title,
+              itemId: r.itemId,
+              itemName: item ? item.name : r.itemId,
+              uid: r.uid,
+              quantity: r.quantity,
+              dateStart: r.dateStart,
+              dateEnd: r.dateEnd,
+              days: r.days || daysBetween(r.dateStart, r.dateEnd),
+              status: r.status,
+              pickupLocation: r.pickupLocation || 'Non précisé',
+            });
+          });
+      }
+
+      rows.sort((a, b) => new Date(a.dateStart) - new Date(b.dateStart));
+      res.json(rows);
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
   });
+};
 
-  // Permissions
-  mountApiBoth(router, 'get', '/calendar/permissions/create', async (req, res) => {
-    const uid = req.user?.uid || 0;
-    const allow = await userCanCreate(uid);
-    res.json({ allow });
-  });
+/* -----------------------------
+ * ACP nav entry
+ * ---------------------------- */
 
-  mountApiBoth(router, 'get', '/calendar/permissions/book', async (req, res) => {
-    const uid = req.user?.uid || 0;
-    const allow = await userCanBook(uid);
-    res.json({ allow });
+Plugin.addAdminNavigation = function (header) {
+  header.plugins.push({
+    // NodeBB ACP will resolve this under /admin
+    route: '/plugins/calendar-onekite',
+    icon: 'fa fa-calendar',
+    name: 'Calendar OneKite',
   });
+  return header;
+};
 
-  // Booking
-  mountApiBoth(router, 'post', '/calendar/event/:eid/book', middleware.ensureLoggedIn, bookReservation);
+/* -----------------------------
+ * Widget
+ * ---------------------------- */
 
-  // My reservations
-  mountApiBoth(router, 'get', '/calendar/my-reservations', middleware.ensureLoggedIn, myReservations);
+Plugin.defineWidgets = async function (widgets) {
+  widgets.push({
+    widget: 'calendarUpcoming',
+    name: 'Prochains événements',
+    description: 'Affiche la liste des prochains événements du calendrier.',
+    content: '',
+  });
+  return widgets;
+};
 
-  // HelloAsso webhook
-  router.post('/api/calendar/helloasso/webhook', helloAssoWebhook);
-  router.post('/api/v3/calendar/helloasso/webhook', helloAssoWebhook);
+Plugin.renderUpcomingWidget = async function (widget, callback) {
+  try {
+    const settings = (await Settings.get(SETTINGS_KEY)) || {};
+    const limit = Number((widget && widget.data && widget.data.limit) || settings.limit || 5);
+    const events = await getUpcomingEvents(limit);
+    const html = await appRef.renderAsync('widgets/calendar-upcoming', { events });
+    widget.html = html;
+    if (typeof callback === 'function') {
+      return callback(null, widget);
+    }
+    return widget;
+  } catch (err) {
+    if (typeof callback === 'function') {
+      return callback(err);
+    }
+    throw err;
+  }
 };
 
 module.exports = Plugin;

package/package.json

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