nodebb-plugin-calendar-onekite 11.1.69 → 11.1.71

package/lib/admin.js

@@ -131,12 +131,14 @@ admin.approveReservation = async function (req, res) {
     const base = forumBaseUrl();
     const returnUrl = base ? `${base}/calendar` : '';
     const webhookUrl = base ? `${base}/plugins/calendar-onekite/helloasso` : '';
+    const year = new Date(Number(r.start)).getFullYear();
     paymentUrl = await helloasso.createCheckoutIntent({
       env,
       token,
       organizationSlug: settings.helloassoOrganizationSlug,
       formType: settings.helloassoFormType,
-      formSlug: settings.helloassoFormSlug,
+      // Form slug is derived from the year
+      formSlug: `locations-materiel-${year}`,
       totalAmount,
       payerEmail: requester && requester.email,
       // User return/back/error URLs must be real pages; webhook uses the plugin endpoint.
@@ -266,12 +268,13 @@ admin.debugHelloAsso = async function (req, res) {
 
     // Catalog items (via /public)
     try {
+      const y = new Date().getFullYear();
       const { publicForm, items } = await helloasso.listCatalogItems({
         env,
         token,
         organizationSlug: settings.helloassoOrganizationSlug,
         formType: settings.helloassoFormType,
-        formSlug: settings.helloassoFormSlug,
+        formSlug: `locations-materiel-${y}`,
       });
 
       const arr = Array.isArray(items) ? items : [];
@@ -289,12 +292,13 @@ admin.debugHelloAsso = async function (req, res) {
 
     // Sold items
     try {
+      const y2 = new Date().getFullYear();
       const items = await helloasso.listItems({
         env,
         token,
         organizationSlug: settings.helloassoOrganizationSlug,
         formType: settings.helloassoFormType,
-        formSlug: settings.helloassoFormSlug,
+        formSlug: `locations-materiel-${y2}`,
       });
       const arr = Array.isArray(items) ? items : [];
       out.soldItems.ok = true;

package/lib/api.js

@@ -114,9 +114,26 @@ function toTs(v) {
   return d.getTime();
 }
 
-async function canRequest(uid, settings) {
-  const allowed = (settings.creatorGroups || settings.allowedGroups || '').split(',').map(s => s.trim()).filter(Boolean);
-  if (!allowed.length) return true; // if empty, allow all logged in users
+function yearFromTs(ts) {
+  const d = new Date(Number(ts));
+  return Number.isFinite(d.getTime()) ? d.getFullYear() : new Date().getFullYear();
+}
+
+function autoCreatorGroupForYear(year) {
+  return `onekite-ffvl-${year}`;
+}
+
+function autoFormSlugForYear(year) {
+  return `locations-materiel-${year}`;
+}
+
+async function canRequest(uid, settings, startTs) {
+  const year = yearFromTs(startTs);
+  const defaultGroup = autoCreatorGroupForYear(year);
+  const extras = (settings.creatorGroups || settings.allowedGroups || '').split(',').map(s => s.trim()).filter(Boolean);
+  const allowed = [defaultGroup, ...extras].filter(Boolean);
+  // If only the default group exists, enforce membership (do not open access to all).
+  if (!allowed.length) return true;
   for (const g of allowed) {
     const isMember = await groups.isMember(uid, g);
     if (isMember) return true;
@@ -143,6 +160,38 @@ async function canValidate(uid, settings) {
   return false;
 }
 
+async function canCreateSpecial(uid, settings) {
+  if (!uid) return false;
+  try {
+    const isAdmin = await groups.isMember(uid, 'administrators');
+    if (isAdmin) return true;
+    const isGlobalMod = await groups.isMember(uid, 'Global Moderators');
+    if (isGlobalMod) return true;
+  } catch (e) {}
+  const allowed = (settings.specialCreatorGroups || '').split(',').map(s => s.trim()).filter(Boolean);
+  if (!allowed.length) return false;
+  for (const g of allowed) {
+    if (await groups.isMember(uid, g)) return true;
+  }
+  return false;
+}
+
+async function canDeleteSpecial(uid, settings) {
+  if (!uid) return false;
+  try {
+    const isAdmin = await groups.isMember(uid, 'administrators');
+    if (isAdmin) return true;
+    const isGlobalMod = await groups.isMember(uid, 'Global Moderators');
+    if (isGlobalMod) return true;
+  } catch (e) {}
+  const allowed = (settings.specialDeleterGroups || settings.specialCreatorGroups || '').split(',').map(s => s.trim()).filter(Boolean);
+  if (!allowed.length) return false;
+  for (const g of allowed) {
+    if (await groups.isMember(uid, g)) return true;
+  }
+  return false;
+}
+
 function eventsFor(resv) {
   const status = resv.status;
   const icons = { pending: '⏳', awaiting_payment: '💳', paid: '✅' };
@@ -179,6 +228,32 @@ function eventsFor(resv) {
   return out;
 }
 
+function eventsForSpecial(ev) {
+  const start = new Date(parseInt(ev.start, 10));
+  const end = new Date(parseInt(ev.end, 10));
+  const startIso = start.toISOString();
+  const endIso = end.toISOString();
+  return {
+    id: `special:${ev.eid}`,
+    title: `📌 ${ev.title || 'Évènement'}`.trim(),
+    allDay: false,
+    start: startIso,
+    end: endIso,
+    color: '#8e44ad',
+    extendedProps: {
+      type: 'special',
+      eid: ev.eid,
+      title: ev.title || '',
+      notes: ev.notes || '',
+      pickupAddress: ev.address || '',
+      pickupLat: ev.lat || '',
+      pickupLon: ev.lon || '',
+      createdBy: ev.uid || 0,
+      username: ev.username || '',
+    },
+  };
+}
+
 const api = {};
 
 api.getEvents = async function (req, res) {
@@ -187,6 +262,8 @@ api.getEvents = async function (req, res) {
 
   const settings = await meta.settings.get('calendar-onekite');
   const canMod = req.uid ? await canValidate(req.uid, settings) : false;
+  const canSpecialCreate = req.uid ? await canCreateSpecial(req.uid, settings) : false;
+  const canSpecialDelete = req.uid ? await canDeleteSpecial(req.uid, settings) : false;
 
   // Fetch a wider window because an event can start before the query range
   // and still overlap.
@@ -221,9 +298,89 @@ api.getEvents = async function (req, res) {
       out.push(ev);
     }
   }
+
+  // Special events
+  try {
+    const specialIds = await dbLayer.listSpecialIdsByStartRange(wideStart, endTs, 5000);
+    for (const eid of specialIds) {
+      const sev = await dbLayer.getSpecialEvent(eid);
+      if (!sev) continue;
+      const sStart = parseInt(sev.start, 10);
+      const sEnd = parseInt(sev.end, 10);
+      if (!(sStart < endTs && startTs < sEnd)) continue;
+      const ev = eventsForSpecial(sev);
+      ev.extendedProps.canCreateSpecial = canSpecialCreate;
+      ev.extendedProps.canDeleteSpecial = canSpecialDelete;
+      // Show creator username only to moderators/allowed users
+      if (sev.username && (canMod || canSpecialDelete || (req.uid && String(req.uid) === String(sev.uid)))) {
+        ev.extendedProps.username = String(sev.username);
+      }
+      out.push(ev);
+    }
+  } catch (e) {
+    // ignore
+  }
   res.json(out);
 };
 
+api.getCapabilities = async function (req, res) {
+  const settings = await meta.settings.get('calendar-onekite');
+  const uid = req.uid || 0;
+  const canMod = uid ? await canValidate(uid, settings) : false;
+  res.json({
+    canModerate: canMod,
+    canCreateSpecial: uid ? await canCreateSpecial(uid, settings) : false,
+    canDeleteSpecial: uid ? await canDeleteSpecial(uid, settings) : false,
+  });
+};
+
+api.createSpecialEvent = async function (req, res) {
+  const settings = await meta.settings.get('calendar-onekite');
+  if (!req.uid) return res.status(401).json({ error: 'not-logged-in' });
+  const ok = await canCreateSpecial(req.uid, settings);
+  if (!ok) return res.status(403).json({ error: 'not-allowed' });
+
+  const title = String((req.body && req.body.title) || '').trim() || 'Évènement';
+  const startTs = toTs(req.body && req.body.start);
+  const endTs = toTs(req.body && req.body.end);
+  if (!Number.isFinite(startTs) || !Number.isFinite(endTs) || !(startTs < endTs)) {
+    return res.status(400).json({ error: 'bad-dates' });
+  }
+  const address = String((req.body && req.body.address) || '').trim();
+  const notes = String((req.body && req.body.notes) || '').trim();
+  const lat = String((req.body && req.body.lat) || '').trim();
+  const lon = String((req.body && req.body.lon) || '').trim();
+
+  const u = await user.getUserFields(req.uid, ['username']);
+  const eid = crypto.randomUUID();
+  const ev = {
+    eid,
+    title,
+    start: String(startTs),
+    end: String(endTs),
+    address,
+    notes,
+    lat,
+    lon,
+    uid: String(req.uid),
+    username: u && u.username ? String(u.username) : '',
+    createdAt: String(Date.now()),
+  };
+  await dbLayer.saveSpecialEvent(ev);
+  res.json({ ok: true, eid });
+};
+
+api.deleteSpecialEvent = async function (req, res) {
+  const settings = await meta.settings.get('calendar-onekite');
+  if (!req.uid) return res.status(401).json({ error: 'not-logged-in' });
+  const ok = await canDeleteSpecial(req.uid, settings);
+  if (!ok) return res.status(403).json({ error: 'not-allowed' });
+  const eid = String(req.params.eid || '').replace(/^special:/, '').trim();
+  if (!eid) return res.status(400).json({ error: 'bad-id' });
+  await dbLayer.removeSpecialEvent(eid);
+  res.json({ ok: true });
+};
+
 api.getItems = async function (req, res) {
   const settings = await meta.settings.get('calendar-onekite');
 
@@ -243,12 +400,14 @@ api.getItems = async function (req, res) {
 
   // Important: the /items endpoint on HelloAsso lists *sold items*.
   // For a shop catalog, use the /public form endpoint and extract the catalog.
+  const year = new Date().getFullYear();
   const { items: catalog } = await helloasso.listCatalogItems({
     env,
     token,
     organizationSlug: settings.helloassoOrganizationSlug,
     formType: settings.helloassoFormType,
-    formSlug: settings.helloassoFormSlug,
+    // Form slug is derived from the year
+    formSlug: autoFormSlugForYear(year),
   });
 
   const normalized = (catalog || []).map((it) => ({
@@ -265,7 +424,8 @@ api.createReservation = async function (req, res) {
   if (!uid) return res.status(401).json({ error: 'not-logged-in' });
 
   const settings = await meta.settings.get('calendar-onekite');
-  const ok = await canRequest(uid, settings);
+  const startPreview = toTs(req.body.start);
+  const ok = await canRequest(uid, settings, startPreview);
   if (!ok) return res.status(403).json({ error: 'not-allowed' });
 
   const start = parseInt(toTs(req.body.start), 10);
@@ -396,12 +556,14 @@ api.approveReservation = async function (req, res) {
     const settings2 = await meta.settings.get('calendar-onekite');
     const token = await helloasso.getAccessToken({ env: settings2.helloassoEnv || 'prod', clientId: settings2.helloassoClientId, clientSecret: settings2.helloassoClientSecret });
     const payer = await user.getUserFields(r.uid, ['email']);
+    const year = yearFromTs(r.start);
     const intent = await helloasso.createCheckoutIntent({
       env: settings2.helloassoEnv,
       token,
       organizationSlug: settings2.helloassoOrganizationSlug,
       formType: settings2.helloassoFormType,
-      formSlug: settings2.helloassoFormSlug,
+      // Form slug is derived from the year of the reservation start date
+      formSlug: autoFormSlugForYear(year),
       // r.total is stored as an estimated total in euros; HelloAsso expects cents.
       totalAmount: (() => {
         const cents = Math.max(0, Math.round((Number(r.total) || 0) * 100));

package/lib/db.js

@@ -6,6 +6,10 @@ const KEY_ZSET = 'calendar-onekite:reservations';
 const KEY_OBJ = (rid) => `calendar-onekite:reservation:${rid}`;
 const KEY_CHECKOUT_INTENT_TO_RID = 'calendar-onekite:helloasso:checkoutIntentToRid';
 
+// Special events (non-reservation events shown in a different colour)
+const KEY_SPECIAL_ZSET = 'calendar-onekite:special';
+const KEY_SPECIAL_OBJ = (eid) => `calendar-onekite:special:${eid}`;
+
 async function getReservation(rid) {
   return await db.getObject(KEY_OBJ(rid));
 }
@@ -43,10 +47,26 @@ async function listAllReservationIds(limit = 5000) {
 
 module.exports = {
   KEY_ZSET,
+  KEY_SPECIAL_ZSET,
   KEY_CHECKOUT_INTENT_TO_RID,
   getReservation,
   saveReservation,
   removeReservation,
+  // Special events
+  getSpecialEvent: async (eid) => await db.getObject(KEY_SPECIAL_OBJ(eid)),
+  saveSpecialEvent: async (ev) => {
+    await db.setObject(KEY_SPECIAL_OBJ(ev.eid), ev);
+    await db.sortedSetAdd(KEY_SPECIAL_ZSET, ev.start, ev.eid);
+  },
+  removeSpecialEvent: async (eid) => {
+    await db.sortedSetRemove(KEY_SPECIAL_ZSET, eid);
+    await db.delete(KEY_SPECIAL_OBJ(eid));
+  },
+  listSpecialIdsByStartRange: async (startTs, endTs, limit = 2000) => {
+    const start = 0;
+    const stop = Math.max(0, (parseInt(limit, 10) || 2000) - 1);
+    return await db.getSortedSetRangeByScore(KEY_SPECIAL_ZSET, start, stop, startTs, endTs);
+  },
   listReservationIdsByStartRange,
   listAllReservationIds,
 };

package/lib/scheduler.js

@@ -5,10 +5,17 @@ const dbLayer = require('./db');
 
 let timer = null;
 
+function getSetting(settings, key, fallback) {
+  const v = settings && Object.prototype.hasOwnProperty.call(settings, key) ? settings[key] : undefined;
+  if (v == null || v === '') return fallback;
+  if (typeof v === 'object' && v && typeof v.value !== 'undefined') return v.value;
+  return v;
+}
+
 // Pending holds: short lock after a user creates a request (defaults to 5 minutes)
 async function expirePending() {
   const settings = await meta.settings.get('calendar-onekite');
-  const holdMins = parseInt(settings.pendingHoldMinutes || '5', 10) || 5;
+  const holdMins = parseInt(getSetting(settings, 'pendingHoldMinutes', '5'), 10) || 5;
   const now = Date.now();
 
   const ids = await dbLayer.listAllReservationIds(5000);
@@ -36,7 +43,10 @@ async function expirePending() {
 // - We expire (and remove) after `2 * paymentHoldMinutes`
 async function processAwaitingPayment() {
   const settings = await meta.settings.get('calendar-onekite');
-  const holdMins = parseInt(settings.paymentHoldMinutes || settings.holdMinutes || '60', 10) || 60;
+  const holdMins = parseInt(
+    getSetting(settings, 'paymentHoldMinutes', getSetting(settings, 'holdMinutes', '60')),
+    10
+  ) || 60;
   const now = Date.now();
 
   const ids = await dbLayer.listAllReservationIds(5000);

package/library.js

@@ -64,10 +64,22 @@ Plugin.init = async function (params) {
     router.get(p, ...publicExpose, api.getItems);
   });
 
+  ['/api/v3/plugins/calendar-onekite/capabilities', '/api/plugins/calendar-onekite/capabilities'].forEach((p) => {
+    router.get(p, ...publicExpose, api.getCapabilities);
+  });
+
   ['/api/v3/plugins/calendar-onekite/reservations', '/api/plugins/calendar-onekite/reservations'].forEach((p) => {
     router.post(p, ...publicAuth, api.createReservation);
   });
 
+  // Special events (other colour) - created/deleted by configured groups
+  ['/api/v3/plugins/calendar-onekite/special-events', '/api/plugins/calendar-onekite/special-events'].forEach((p) => {
+    router.post(p, ...publicAuth, api.createSpecialEvent);
+  });
+  ['/api/v3/plugins/calendar-onekite/special-events/:eid', '/api/plugins/calendar-onekite/special-events/:eid'].forEach((p) => {
+    router.delete(p, ...publicAuth, api.deleteSpecialEvent);
+  });
+
   // Validator actions from the calendar popup (requires login + validatorGroups)
   ['/api/v3/plugins/calendar-onekite/reservations/:rid/approve', '/api/plugins/calendar-onekite/reservations/:rid/approve'].forEach((p) => {
     router.put(p, ...publicAuth, api.approveReservation);

package/package.json

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

package/plugin.json

@@ -27,5 +27,5 @@
   "acpScripts": [
     "public/admin.js"
   ],
-  "version": "1.0.40"
+  "version": "1.0.46"
 }

package/public/admin.js

@@ -138,6 +138,49 @@ define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts
     });
   }
 
+  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');
@@ -396,10 +439,34 @@ define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts
     const form = document.getElementById('onekite-settings-form');
     if (!form) return;
 
+    // Inject missing settings fields if the template is older
+    function ensureTextInput(name, label, help) {
+      if (form.querySelector(`[name="${name}"]`)) return;
+      const div = document.createElement('div');
+      div.className = 'mb-3';
+      div.innerHTML = `
+        <label class="form-label">${label}</label>
+        <input type="text" class="form-control" name="${name}" placeholder="" />
+        ${help ? `<div class="form-text">${help}</div>` : ''}
+      `;
+      form.appendChild(div);
+    }
+
+    ensureTextInput('specialCreatorGroups', 'Groupes autorisés à créer des évènements (csv)', 'Ex: groupA,groupB');
+    ensureTextInput('specialDeleterGroups', 'Groupes autorisés à supprimer des évènements (csv)', 'Par défaut, si vide : même liste que la création');
+
     // 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.');
     }
@@ -426,7 +493,14 @@ define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts
       doSave._inFlight = true;
       try {
         if (ev && typeof ev.preventDefault === 'function') ev.preventDefault();
-        await saveSettings(formToObject(form));
+        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.');
@@ -435,9 +509,9 @@ define('admin/plugins/calendar-onekite', ['alerts', 'bootbox'], function (alerts
       }
     }
 
-    // Save buttons (bottom button + NodeBB header/footer "Enregistrer" + floppy icon)
+    // Save buttons (NodeBB header/footer "Enregistrer" + floppy icon)
     // Use ONE delegated listener to avoid double submissions.
-    const SAVE_SELECTOR = '#onekite-save, #save, .save, [data-action="save"], .settings-save, .floating-save, .btn[data-action="save"]';
+    const SAVE_SELECTOR = '#save, .save, [data-action="save"], .settings-save, .floating-save, .btn[data-action="save"]';
     document.addEventListener('click', (ev) => {
       const btn = ev.target && ev.target.closest && ev.target.closest(SAVE_SELECTOR);
       if (!btn) return;

package/public/client.js

@@ -16,6 +16,108 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
       .replace(/'/g, ''');
   }
 
+  async function openSpecialEventDialog(selectionInfo) {
+    const start = selectionInfo.start;
+    const end = selectionInfo.end;
+    const html = `
+      <div class="mb-3">
+        <label class="form-label">Titre</label>
+        <input type="text" class="form-control" id="onekite-se-title" placeholder="Ex: ..." />
+      </div>
+      <div class="row g-2">
+        <div class="col-12 col-md-6">
+          <label class="form-label">Début</label>
+          <input type="datetime-local" class="form-control" id="onekite-se-start" value="${escapeHtml(toDatetimeLocalValue(start))}" />
+        </div>
+        <div class="col-12 col-md-6">
+          <label class="form-label">Fin</label>
+          <input type="datetime-local" class="form-control" id="onekite-se-end" value="${escapeHtml(toDatetimeLocalValue(end))}" />
+        </div>
+      </div>
+      <div class="mt-3">
+        <label class="form-label">Adresse</label>
+        <div class="input-group">
+          <input type="text" class="form-control" id="onekite-se-address" placeholder="Adresse complète" />
+          <button class="btn btn-outline-secondary" type="button" id="onekite-se-geocode">Rechercher</button>
+        </div>
+        <div id="onekite-se-map" style="height:220px; border:1px solid #ddd; border-radius:6px; margin-top:0.5rem;"></div>
+        <input type="hidden" id="onekite-se-lat" />
+        <input type="hidden" id="onekite-se-lon" />
+      </div>
+      <div class="mt-3">
+        <label class="form-label">Notes (facultatif)</label>
+        <textarea class="form-control" id="onekite-se-notes" rows="3" placeholder="..."></textarea>
+      </div>
+    `;
+
+    return await new Promise((resolve) => {
+      bootbox.dialog({
+        title: 'Créer un évènement',
+        message: html,
+        buttons: {
+          cancel: {
+            label: 'Annuler',
+            className: 'btn-secondary',
+            callback: () => resolve(null),
+          },
+          ok: {
+            label: 'Créer',
+            className: 'btn-primary',
+            callback: () => {
+              const title = (document.getElementById('onekite-se-title')?.value || '').trim();
+              const startVal = (document.getElementById('onekite-se-start')?.value || '').trim();
+              const endVal = (document.getElementById('onekite-se-end')?.value || '').trim();
+              const address = (document.getElementById('onekite-se-address')?.value || '').trim();
+              const notes = (document.getElementById('onekite-se-notes')?.value || '').trim();
+              const lat = (document.getElementById('onekite-se-lat')?.value || '').trim();
+              const lon = (document.getElementById('onekite-se-lon')?.value || '').trim();
+              resolve({ title, start: startVal, end: endVal, address, notes, lat, lon });
+              return true;
+            },
+          },
+        },
+      });
+
+      // init leaflet
+      setTimeout(async () => {
+        try {
+          const mapEl = document.getElementById('onekite-se-map');
+          if (!mapEl) return;
+          const L = await loadLeaflet();
+          const map = L.map(mapEl).setView([46.5, 2.5], 5);
+          L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', { maxZoom: 19, attribution: '&copy; OpenStreetMap' }).addTo(map);
+          let marker = null;
+          function setMarker(lat, lon) {
+            if (marker) map.removeLayer(marker);
+            marker = L.marker([lat, lon], { draggable: true }).addTo(map);
+            marker.on('dragend', () => {
+              const p = marker.getLatLng();
+              document.getElementById('onekite-se-lat').value = String(p.lat);
+              document.getElementById('onekite-se-lon').value = String(p.lng);
+            });
+            document.getElementById('onekite-se-lat').value = String(lat);
+            document.getElementById('onekite-se-lon').value = String(lon);
+            map.setView([lat, lon], 14);
+          }
+          const geocodeBtn = document.getElementById('onekite-se-geocode');
+          const addrInput = document.getElementById('onekite-se-address');
+          geocodeBtn?.addEventListener('click', async () => {
+            const q = (addrInput?.value || '').trim();
+            if (!q) return;
+            const hit = await geocodeAddress(q);
+            if (hit && hit.lat && hit.lon) {
+              setMarker(hit.lat, hit.lon);
+            } else {
+              showAlert('error', 'Adresse introuvable.');
+            }
+          });
+        } catch (e) {
+          // ignore leaflet errors
+        }
+      }, 0);
+    });
+  }
+
   function statusLabel(s) {
     const map = {
       pending: 'En attente',
@@ -60,6 +162,14 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
     return await res.json();
   }
 
+  async function loadCapabilities() {
+    try {
+      return await fetchJson('/api/v3/plugins/calendar-onekite/capabilities');
+    } catch (e) {
+      return await fetchJson('/api/plugins/calendar-onekite/capabilities');
+    }
+  }
+
   // Leaflet (OpenStreetMap) helpers - loaded lazily only when needed.
   let leafletPromise = null;
   function loadLeaflet() {
@@ -167,6 +277,12 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
     }
   }
 
+  function toDatetimeLocalValue(date) {
+    const d = new Date(date);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  }
+
   async function openReservationDialog(selectionInfo, items) {
     const start = selectionInfo.start;
     const end = selectionInfo.end;
@@ -287,12 +403,31 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
     }
 
     const items = await loadItems();
+    const caps = await loadCapabilities().catch(() => ({}));
+    const canCreateSpecial = !!caps.canCreateSpecial;
+    const canDeleteSpecial = !!caps.canDeleteSpecial;
+
+    let mode = 'reservation'; // or 'special'
 
     const calendar = new FullCalendar.Calendar(el, {
       initialView: 'dayGridMonth',
       locale: 'fr',
-      // Do not display hours anywhere
-      displayEventTime: false,
+      headerToolbar: {
+        left: 'prev,next today',
+        center: 'title',
+        right: (canCreateSpecial ? 'newSpecial ' : '') + 'dayGridMonth,timeGridWeek,timeGridDay',
+      },
+      customButtons: canCreateSpecial ? {
+        newSpecial: {
+          text: 'Évènement',
+          click: () => {
+            mode = 'special';
+            showAlert('success', 'Mode évènement : sélectionne une plage (date/heure) sur le calendrier.');
+          },
+        },
+      } : {},
+      // Display time for special events, but keep reservations as all-day events
+      displayEventTime: true,
       selectable: true,
       selectMirror: true,
       events: async function (info, successCallback, failureCallback) {
@@ -310,6 +445,30 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
         }
         isDialogOpen = true;
         try {
+          if (mode === 'special' && canCreateSpecial) {
+            const payload = await openSpecialEventDialog(info);
+            mode = 'reservation';
+            if (!payload) {
+              calendar.unselect();
+              isDialogOpen = false;
+              return;
+            }
+            await fetchJson('/api/v3/plugins/calendar-onekite/special-events', {
+              method: 'POST',
+              body: JSON.stringify(payload),
+            }).catch(async () => {
+              return await fetchJson('/api/plugins/calendar-onekite/special-events', {
+                method: 'POST',
+                body: JSON.stringify(payload),
+              });
+            });
+            showAlert('success', 'Évènement créé.');
+            calendar.refetchEvents();
+            calendar.unselect();
+            isDialogOpen = false;
+            return;
+          }
+
           if (!items || !items.length) {
             showAlert('error', 'Aucun matériel disponible (items HelloAsso non chargés).');
             calendar.unselect();
@@ -323,9 +482,11 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
             return;
           }
           // Send date strings (no hours) so reservations are day-based.
+          const startDate = new Date(info.start).toISOString().slice(0, 10);
+          const endDate = new Date(info.end).toISOString().slice(0, 10);
           await requestReservation({
-            start: info.startStr,
-            end: info.endStr,
+            start: startDate,
+            end: endDate,
             itemIds: chosen.itemIds,
             itemNames: chosen.itemNames,
             total: chosen.total,
@@ -357,6 +518,47 @@ define('forum/calendar-onekite', ['alerts', 'bootbox', 'hooks'], function (alert
       eventClick: async function (info) {
         const ev = info.event;
         const p = ev.extendedProps || {};
+        if (p.type === 'special') {
+          const username = String(p.username || '').trim();
+          const userLine = username
+            ? `<div class="mb-2"><strong>Créé par</strong><br><a href="${window.location.origin}/user/${encodeURIComponent(username)}">${escapeHtml(username)}</a></div>`
+            : '';
+          const addr = String(p.pickupAddress || '').trim();
+          const notes = String(p.notes || '').trim();
+          const html = `
+            <div class="mb-2"><strong>Titre</strong><br>${escapeHtml(p.title || ev.title || '')}</div>
+            ${userLine}
+            <div class="mb-2"><strong>Période</strong><br>${escapeHtml(formatDt(ev.start))} → ${escapeHtml(formatDt(ev.end))}</div>
+            ${addr ? `<div class="mb-2"><strong>Adresse</strong><br>${escapeHtml(addr)}</div>` : ''}
+            ${notes ? `<div class="mb-2"><strong>Notes</strong><br>${escapeHtml(notes).replace(/\n/g,'<br>')}</div>` : ''}
+          `;
+          const canDel = !!(p.canDeleteSpecial || canDeleteSpecial);
+          bootbox.dialog({
+            title: 'Évènement',
+            message: html,
+            buttons: {
+              close: { label: 'Fermer', className: 'btn-secondary' },
+              ...(canDel ? {
+                del: {
+                  label: 'Supprimer',
+                  className: 'btn-danger',
+                  callback: async () => {
+                    try {
+                      const eid = String(p.eid || ev.id).replace(/^special:/, '');
+                      await fetchJson(`/api/v3/plugins/calendar-onekite/special-events/${encodeURIComponent(eid)}`, { method: 'DELETE' })
+                        .catch(() => fetchJson(`/api/plugins/calendar-onekite/special-events/${encodeURIComponent(eid)}`, { method: 'DELETE' }));
+                      showAlert('success', 'Évènement supprimé.');
+                      calendar.refetchEvents();
+                    } catch (e) {
+                      showAlert('error', 'Suppression impossible.');
+                    }
+                  },
+                },
+              } : {}),
+            },
+          });
+          return;
+        }
         const rid = p.rid || ev.id;
         const status = p.status || '';
 

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

@@ -85,7 +85,6 @@
             <input class="form-control" name="helloassoFormSlug">
           </div>
 
-          <button type="button" class="btn btn-primary" id="onekite-save">Enregistrer</button>
         </form>
       </div>