nodebb-plugin-calendar-onekite 12.0.17 → 12.0.19

package/lib/api.js

@@ -12,11 +12,22 @@ const logger = require.main.require('./src/logger');
 
 const dbLayer = require('./db');
 
+// Fast membership check without N calls to groups.isMember.
+// NodeBB's groups.getUserGroups([uid]) returns an array (per uid) of group objects.
+// We compare against both group slugs and names to be tolerant with older settings.
 async function userInAnyGroup(uid, allowed) {
-  if (!uid || !allowed || !allowed.length) return false;
+  if (!uid || !Array.isArray(allowed) || !allowed.length) return false;
   const ug = await groups.getUserGroups([uid]);
-  const slugs = ug[0] || [];
-  return allowed.some(g => slugs.includes(g));
+  const list = (ug && ug[0]) ? ug[0] : [];
+  const seen = new Set();
+  for (const g of list) {
+    if (!g) continue;
+    if (g.slug) seen.add(String(g.slug));
+    if (g.name) seen.add(String(g.name));
+    if (g.groupName) seen.add(String(g.groupName));
+    if (g.displayName) seen.add(String(g.displayName));
+  }
+  return allowed.some(v => seen.has(String(v)));
 }
 
 
@@ -35,20 +46,11 @@ function normalizeAllowedGroups(raw) {
   return s.split(',').map(v => String(v).trim().replace(/^"+|"+$/g, '')).filter(Boolean);
 }
 
-async function isMemberOfAnyGroup(uid, allowed) {
-  if (!uid || !allowed || !allowed.length) return false;
-  for (const g of allowed) {
-    try {
-      if (await groups.isMember(uid, g)) return true;
-    } catch (e) {
-      // ignore
-    }
-  }
-  return false;
-}
+// NOTE: Avoid per-group async checks (groups.isMember) when possible.
 
 
 const helloasso = require('./helloasso');
+const discord = require('./discord');
 
 // Email helper: NodeBB's Emailer signature differs across versions.
 // We try the common forms. Any failure is logged for debugging.
@@ -160,53 +162,8 @@ function autoCreatorGroupForYear(year) {
 }
 
 
-async function resolveGroupName(maybeSlugOrName) {
-  const g = String(maybeSlugOrName || '').trim();
-  if (!g) return '';
-  try {
-    // NodeBB stores a mapping from slug -> groupName in groupslug:groupname
-    // groupName is the internal identifier used by groups.isMember()
-    const mapped = await db.getObjectField('groupslug:groupname', g);
-    if (mapped) return String(mapped);
-  } catch (e) {}
-  return g;
-}
-
-async function resolveAllowedGroups(list) {
-  const out = [];
-  for (const raw of (list || [])) {
-    const gn = await resolveGroupName(raw);
-    if (gn) out.push(gn);
-  }
-  // de-duplicate, preserve order
-  return [...new Set(out)];
-}
-
-
-async function expandGroupCandidates(rawList) {
-  const out = [];
-  for (const raw of (rawList || [])) {
-    const g = String(raw || '').trim();
-    if (!g) continue;
-    out.push(g);
-    const mapped = await resolveGroupName(g);
-    if (mapped && mapped !== g) out.push(mapped);
-  }
-  return [...new Set(out)];
-}
-
-async function checkAnyMembership(uid, rawList, fnLabel) {
-  const candidates = await expandGroupCandidates(rawList);
-  for (const g of candidates) {
-    try {
-      const ok = await groups.isMember(uid, g);
-      if (ok) return { ok: true, matched: g, candidates };
-    } catch (e) {
-      logger.warn('[calendar-onekite] auth check error', { uid, group: g, fn: fnLabel, err: String(e && e.message || e) });
-    }
-  }
-  return { ok: false, matched: '', candidates };
-}
+// (removed) group slug/name resolving helpers: we now use userInAnyGroup() which
+// matches both slugs and names and avoids extra DB lookups.
 
 
 function autoFormSlugForYear(year) {
@@ -278,8 +235,7 @@ async function canDeleteSpecial(uid, settings) {
   try {
     const isAdmin = await groups.isMember(uid, 'administrators');
     if (isAdmin) return true;} catch (e) {}
-  const rawAllowed = (settings.specialDeleterGroups || settings.specialCreatorGroups || '').split(',').map(s => s.trim()).filter(Boolean);
-  const allowed = await resolveAllowedGroups(rawAllowed);
+  const allowed = normalizeAllowedGroups(settings.specialDeleterGroups || settings.specialCreatorGroups || '');
   if (!allowed.length) return false;
   if (await userInAnyGroup(uid, allowed)) return true;
 
@@ -378,8 +334,9 @@ api.getEvents = async function (req, res) {
   const wideStart = Math.max(0, startTs - 366 * 24 * 3600 * 1000);
   const ids = await dbLayer.listReservationIdsByStartRange(wideStart, endTs, 5000);
   const out = [];
-  for (const rid of ids) {
-    const r = await dbLayer.getReservation(rid);
+  // Batch fetch = major perf win when there are many reservations.
+  const reservations = await dbLayer.getReservations(ids);
+  for (const r of (reservations || [])) {
     if (!r) continue;
     // Purged from calendar view (kept for accounting)
     if (r.calendarPurgedAt) continue;
@@ -425,8 +382,8 @@ api.getEvents = async function (req, res) {
   // Special events
   try {
     const specialIds = await dbLayer.listSpecialIdsByStartRange(wideStart, endTs, 5000);
-    for (const eid of specialIds) {
-      const sev = await dbLayer.getSpecialEvent(eid);
+    const specials = await dbLayer.getSpecialEvents(specialIds);
+    for (const sev of (specials || [])) {
       if (!sev) continue;
       const sStart = parseInt(sev.start, 10);
       const sEnd = parseInt(sev.end, 10);
@@ -677,8 +634,8 @@ api.createReservation = async function (req, res) {
   const wideStart2 = Math.max(0, start - 366 * 24 * 3600 * 1000);
   const candidateIds = await dbLayer.listReservationIdsByStartRange(wideStart2, end, 5000);
   const conflicts = [];
-  for (const cid of candidateIds) {
-    const existing = await dbLayer.getReservation(cid);
+  const existingRows = await dbLayer.getReservations(candidateIds);
+  for (const existing of (existingRows || [])) {
     if (!existing || !blocking.has(existing.status)) continue;
     const exStart = parseInt(existing.start, 10);
     const exEnd = parseInt(existing.end, 10);
@@ -729,24 +686,35 @@ api.createReservation = async function (req, res) {
       const itemsLabel = (resv.itemNames || []).join(', ');
       for (const g of notifyGroups) {
         const members = await groups.getMembers(g, 0, -1);
-        for (const memberUid of (members || [])) {
-          const md = await user.getUserFields(memberUid, ['username', 'email']);
+        const uids = Array.isArray(members) ? members : [];
+
+        // Batch fetch user email/username when supported by this NodeBB version.
+        let usersData = [];
+        try {
+          if (typeof user.getUsersFields === 'function') {
+            usersData = await user.getUsersFields(uids, ['username', 'email']);
+          } else {
+            usersData = await Promise.all(uids.map(async (memberUid) => {
+              try { return await user.getUserFields(memberUid, ['username', 'email']); }
+              catch (e) { return null; }
+            }));
+          }
+        } catch (e) {
+          usersData = [];
+        }
+
+        for (const md of (usersData || [])) {
           if (md && md.email) {
-            await sendEmail(
-              'calendar-onekite_pending',
-              md.email,
-              'Location matériel - Demande de réservation',
-              {
-                username: md.username,
-                requester: requester.username,
-                itemName: itemsLabel,
-                itemNames: resv.itemNames || [],
-                dateRange: `Du ${formatFR(start)} au ${formatFR(end)}`,
-                start: formatFR(start),
-                end: formatFR(end),
-                total: resv.total || 0,
-              }
-            );
+            await sendEmail('calendar-onekite_pending', md.email, 'Location matériel - Demande de réservation', {
+              username: md.username,
+              requester: requester.username,
+              itemName: itemsLabel,
+              itemNames: resv.itemNames || [],
+              dateRange: `Du ${formatFR(start)} au ${formatFR(end)}`,
+              start: formatFR(start),
+              end: formatFR(end),
+              total: resv.total || 0,
+            });
           }
         }
       }
@@ -755,6 +723,20 @@ api.createReservation = async function (req, res) {
     console.warn('[calendar-onekite] Failed to send pending email', e && e.message ? e.message : e);
   }
 
+  // Discord webhook (optional)
+  try {
+    await discord.notifyReservationRequested(settings, {
+      rid: resv.rid,
+      uid: resv.uid,
+      username: resv.username || '',
+      itemIds: resv.itemIds || [],
+      itemNames: resv.itemNames || [],
+      start: resv.start,
+      end: resv.end,
+      status: resv.status,
+    });
+  } catch (e) {}
+
   res.json({ ok: true, rid });
 };
 

package/lib/db.js

@@ -10,10 +10,36 @@ const KEY_CHECKOUT_INTENT_TO_RID = 'calendar-onekite:helloasso:checkoutIntentToR
 const KEY_SPECIAL_ZSET = 'calendar-onekite:special';
 const KEY_SPECIAL_OBJ = (eid) => `calendar-onekite:special:${eid}`;
 
+// Helpers
+function reservationKey(rid) {
+  return KEY_OBJ(rid);
+}
+
+function specialKey(eid) {
+  return KEY_SPECIAL_OBJ(eid);
+}
+
 async function getReservation(rid) {
   return await db.getObject(KEY_OBJ(rid));
 }
 
+/**
+ * Batch fetch reservations in one DB roundtrip.
+ * Returns an array aligned with rids (missing objects => null).
+ */
+async function getReservations(rids) {
+  const ids = Array.isArray(rids) ? rids.filter(Boolean) : [];
+  if (!ids.length) return [];
+  const keys = ids.map(reservationKey);
+  const rows = await db.getObjects(keys);
+  // Ensure rid is present even if older objects were missing it.
+  return (rows || []).map((row, idx) => {
+    if (!row) return null;
+    if (!row.rid) row.rid = String(ids[idx]);
+    return row;
+  });
+}
+
 async function saveReservation(resv) {
   await db.setObject(KEY_OBJ(resv.rid), resv);
   // score = start timestamp
@@ -50,10 +76,22 @@ module.exports = {
   KEY_SPECIAL_ZSET,
   KEY_CHECKOUT_INTENT_TO_RID,
   getReservation,
+  getReservations,
   saveReservation,
   removeReservation,
   // Special events
   getSpecialEvent: async (eid) => await db.getObject(KEY_SPECIAL_OBJ(eid)),
+  getSpecialEvents: async (eids) => {
+    const ids = Array.isArray(eids) ? eids.filter(Boolean) : [];
+    if (!ids.length) return [];
+    const keys = ids.map(specialKey);
+    const rows = await db.getObjects(keys);
+    return (rows || []).map((row, idx) => {
+      if (!row) return null;
+      if (!row.eid) row.eid = String(ids[idx]);
+      return row;
+    });
+  },
   saveSpecialEvent: async (ev) => {
     await db.setObject(KEY_SPECIAL_OBJ(ev.eid), ev);
     await db.sortedSetAdd(KEY_SPECIAL_ZSET, ev.start, ev.eid);

package/lib/discord.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const https = require('https');
+const { URL } = require('url');
+
+function isEnabled(v, defaultValue) {
+  if (v === undefined || v === null || v === '') return defaultValue !== false;
+  const s = String(v).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(s)) return true;
+  if (['0', 'false', 'no', 'off'].includes(s)) return false;
+  return defaultValue !== false;
+}
+
+function formatFRShort(ts) {
+  const d = new Date(ts);
+  const dd = String(d.getDate()).padStart(2, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const yy = String(d.getFullYear()).slice(-2);
+  return `${dd}/${mm}/${yy}`;
+}
+
+function postWebhook(webhookUrl, payload) {
+  return new Promise((resolve, reject) => {
+    try {
+      const u = new URL(String(webhookUrl));
+      if (u.protocol !== 'https:') {
+        return reject(new Error('discord-webhook-must-be-https'));
+      }
+
+      const body = Buffer.from(JSON.stringify(payload || {}), 'utf8');
+      const req = https.request({
+        method: 'POST',
+        hostname: u.hostname,
+        port: u.port || 443,
+        path: u.pathname + (u.search || ''),
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': body.length,
+          'User-Agent': 'nodebb-plugin-calendar-onekite',
+        },
+      }, (res) => {
+        const ok = res.statusCode && res.statusCode >= 200 && res.statusCode < 300;
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          if (ok) return resolve(true);
+          const msg = Buffer.concat(chunks).toString('utf8');
+          return reject(new Error(`discord-webhook-http-${res.statusCode}: ${msg}`));
+        });
+      });
+      req.on('error', reject);
+      req.write(body);
+      req.end();
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+function buildReservationMessage(kind, reservation) {
+  const calUrl = 'https://www.onekite.com/calendar';
+  const username = reservation && reservation.username ? String(reservation.username) : '';
+  const items = (reservation && Array.isArray(reservation.itemNames) && reservation.itemNames.length)
+    ? reservation.itemNames.map(String)
+    : (reservation && Array.isArray(reservation.itemIds) ? reservation.itemIds.map(String) : []);
+  const start = reservation && reservation.start ? Number(reservation.start) : NaN;
+  const end = reservation && reservation.end ? Number(reservation.end) : NaN;
+
+  const title = kind === 'paid'
+    ? `**[Paiement reçu](${calUrl})** — ${username}`
+    : `**[Demande réservation](${calUrl})** — ${username}`;
+
+  const lines = [
+    title,
+    '',
+    'Contenu du message',
+    '',
+    kind === 'paid' ? '**Matériel :**' : '**Matériel demandé :**',
+  ];
+  for (const it of items) {
+    lines.push(`- ${it}`);
+  }
+  if (Number.isFinite(start) && Number.isFinite(end)) {
+    lines.push('');
+    lines.push(`Du ${formatFRShort(start)} au ${formatFRShort(end)}`);
+  }
+  return lines.join('\n');
+}
+
+async function notifyReservationRequested(settings, reservation) {
+  const url = settings && settings.discordWebhookUrl ? String(settings.discordWebhookUrl).trim() : '';
+  if (!url) return;
+  if (!isEnabled(settings.discordNotifyOnRequest, true)) return;
+
+  try {
+    await postWebhook(url, { content: buildReservationMessage('request', reservation) });
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] Discord webhook failed (request)', e && e.message ? e.message : String(e));
+  }
+}
+
+async function notifyPaymentReceived(settings, reservation) {
+  const url = settings && settings.discordWebhookUrl ? String(settings.discordWebhookUrl).trim() : '';
+  if (!url) return;
+  if (!isEnabled(settings.discordNotifyOnPaid, true)) return;
+
+  try {
+    await postWebhook(url, { content: buildReservationMessage('paid', reservation) });
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] Discord webhook failed (paid)', e && e.message ? e.message : String(e));
+  }
+}
+
+module.exports = {
+  notifyReservationRequested,
+  notifyPaymentReceived,
+};

package/lib/helloassoWebhook.js

@@ -17,6 +17,7 @@ try {
 
 const dbLayer = require('./db');
 const helloasso = require('./helloasso');
+const discord = require('./discord');
 
 const SETTINGS_KEY = 'calendar-onekite';
 
@@ -363,6 +364,20 @@ async function handler(req, res, next) {
       });
     }
 
+    // Discord webhook (optional)
+    try {
+      await discord.notifyPaymentReceived(settings, {
+        rid: r.rid,
+        uid: r.uid,
+        username: (requester && requester.username) ? requester.username : (r.username || ''),
+        itemIds: r.itemIds || (r.itemId ? [r.itemId] : []),
+        itemNames: r.itemNames || (r.itemName ? [r.itemName] : []),
+        start: r.start,
+        end: r.end,
+        status: r.status,
+      });
+    } catch (e) {}
+
     await markProcessed(paymentId);
     return res.json({ ok: true, processed: true });
   } catch (err) {

package/lib/scheduler.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const meta = require.main.require('./src/meta');
+const db = require.main.require('./src/database');
 const dbLayer = require('./db');
 
 let timer = null;
@@ -109,7 +110,16 @@ async function processAwaitingPayment() {
     const expireAt = approvedAt + 2 * holdMins * 60 * 1000;
 
     if (!r.reminderSent && now >= reminderAt && now < expireAt) {
-      // Send reminder once
+      // Send reminder once (guarded across clustered NodeBB processes)
+      const reminderKey = 'calendar-onekite:email:reminderSent';
+      const first = await db.setAdd(reminderKey, rid);
+      if (!first) {
+        // another process already sent it
+        r.reminderSent = true;
+        r.reminderAt = now;
+        await dbLayer.saveReservation(r);
+        continue;
+      }
       const u = await user.getUserFields(r.uid, ['username', 'email']);
       if (u && u.email) {
         await sendEmail('calendar-onekite_reminder', u.email, 'Location matériel - Rappel', {
@@ -130,8 +140,12 @@ async function processAwaitingPayment() {
 
     if (now >= expireAt) {
       // Expire: remove reservation so it disappears from calendar and frees items
+      // Guard email send across clustered NodeBB processes
+      const expiredKey = 'calendar-onekite:email:expiredSent';
+      const firstExpired = await db.setAdd(expiredKey, rid);
+      const shouldEmail = !!firstExpired;
       const u = await user.getUserFields(r.uid, ['username', 'email']);
-      if (u && u.email) {
+      if (shouldEmail && u && u.email) {
         await sendEmail('calendar-onekite_expired', u.email, 'Location matériel - Rappel', {
           username: u.username,
           itemName: (Array.isArray(r.itemNames) ? r.itemNames.join(', ') : (r.itemName || '')),

package/lib/widgets.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const nconf = require.main.require('nconf');
+
+function forumBaseUrl() {
+  return String(nconf.get('url') || '').trim().replace(/\/$/, '');
+}
+
+function escapeHtml(s) {
+  return String(s || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function makeDomId() {
+  const r = Math.floor(Math.random() * 1e9);
+  return `onekite-twoweeks-${Date.now()}-${r}`;
+}
+
+function widgetCalendarUrl() {
+  // Per request, keep the public URL fixed (even if forum base differs)
+  return 'https://www.onekite.com/calendar';
+}
+
+const widgets = {};
+
+widgets.defineWidgets = async function (widgetData) {
+  // NodeBB passes an object with .widgets array.
+  if (!widgetData || !Array.isArray(widgetData.widgets)) {
+    return widgetData;
+  }
+
+  widgetData.widgets.push({
+    widget: 'calendar-onekite-twoweeks',
+    name: 'Calendrier OneKite (2 semaines)',
+    description: 'Affiche la semaine courante + la semaine suivante (FullCalendar via CDN).',
+    content: '',
+  });
+
+  return widgetData;
+};
+
+widgets.renderTwoWeeksWidget = async function (data) {
+  // data: { widget, ... }
+  const id = makeDomId();
+  const calUrl = widgetCalendarUrl();
+  const apiBase = forumBaseUrl();
+  const eventsEndpoint = `${apiBase}/api/v3/plugins/calendar-onekite/events`;
+
+  const idJson = JSON.stringify(id);
+  const calUrlJson = JSON.stringify(calUrl);
+  const eventsEndpointJson = JSON.stringify(eventsEndpoint);
+
+  const html = `
+<div class="onekite-twoweeks">
+  <div class="d-flex justify-content-between align-items-center mb-1">
+    <div style="font-weight: 600;">Calendrier (2 semaines)</div>
+    <a href="${escapeHtml(calUrl)}" class="btn btn-sm btn-outline-secondary" style="line-height: 1.1;">Ouvrir</a>
+  </div>
+  <div id="${escapeHtml(id)}"></div>
+</div>
+
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/fullcalendar@latest/main.min.css" />
+<script>
+(function(){
+  const containerId = ${idJson};
+  const calUrl = ${calUrlJson};
+  const eventsEndpoint = ${eventsEndpointJson};
+
+  function loadOnce(tag, attrs) {
+    return new Promise((resolve, reject) => {
+      try {
+        const key = attrs && (attrs.id || attrs.href || attrs.src);
+        if (key && document.querySelector((attrs.id ? ('#' + attrs.id) : (attrs.href ? ('link[href="' + attrs.href + '"]') : ('script[src="' + attrs.src + '"]'))))) {
+          resolve();
+          return;
+        }
+        const el = document.createElement(tag);
+        Object.keys(attrs || {}).forEach((k) => el.setAttribute(k, attrs[k]));
+        el.onload = () => resolve();
+        el.onerror = () => reject(new Error('load-failed'));
+        document.head.appendChild(el);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  async function ensureFullCalendar() {
+    if (window.FullCalendar && window.FullCalendar.Calendar) {
+      return;
+    }
+    await loadOnce('script', {
+      id: 'onekite-fullcalendar-global',
+      src: 'https://cdn.jsdelivr.net/npm/fullcalendar@latest/index.global.min.js',
+      async: 'true'
+    });
+    await loadOnce('script', {
+      id: 'onekite-fullcalendar-locales',
+      src: 'https://cdn.jsdelivr.net/npm/@fullcalendar/core@latest/locales-all.global.min.js',
+      async: 'true'
+    });
+  }
+
+  async function init() {
+    const el = document.getElementById(containerId);
+    if (!el) return;
+
+    await ensureFullCalendar();
+
+    // Define a 2-week dayGrid view
+    const calendar = new window.FullCalendar.Calendar(el, {
+      initialView: 'dayGridTwoWeek',
+      views: {
+        dayGridTwoWeek: {
+          type: 'dayGrid',
+          duration: { weeks: 2 },
+          buttonText: '2 semaines',
+        },
+      },
+      locale: 'fr',
+      firstDay: 1,
+      height: 'auto',
+      headerToolbar: {
+        left: 'prev,next',
+        center: 'title',
+        right: '',
+      },
+      navLinks: false,
+      eventTimeFormat: { hour: '2-digit', minute: '2-digit', hour12: false },
+      events: function(info, successCallback, failureCallback) {
+        const qs = new URLSearchParams({ start: info.startStr, end: info.endStr });
+        fetch(eventsEndpoint + '?' + qs.toString(), { credentials: 'same-origin' })
+          .then((r) => r.json())
+          .then((json) => successCallback(json || []))
+          .catch((e) => failureCallback(e));
+      },
+      dateClick: function() {
+        window.location.href = calUrl;
+      },
+      eventClick: function() {
+        window.location.href = calUrl;
+      },
+    });
+
+    calendar.render();
+  }
+
+  // Widgets can be rendered after ajaxify; delay a tick.
+  setTimeout(() => init().catch(() => {}), 0);
+})();
+</script>
+
+<style>
+  .onekite-twoweeks .fc .fc-toolbar-title { font-size: 1rem; }
+  .onekite-twoweeks .fc .fc-button { padding: .2rem .35rem; font-size: .75rem; }
+  .onekite-twoweeks .fc .fc-daygrid-day-number { font-size: .75rem; padding: 2px; }
+  .onekite-twoweeks .fc .fc-col-header-cell-cushion { font-size: .75rem; }
+  .onekite-twoweeks .fc .fc-event-title { font-size: .72rem; }
+</style>
+  `;
+
+  data = data || {};
+  data.html = html;
+  return data;
+};
+
+module.exports = widgets;

package/library.js

@@ -12,6 +12,7 @@ const api = require('./lib/api');
 const admin = require('./lib/admin');
 const scheduler = require('./lib/scheduler');
 const helloassoWebhook = require('./lib/helloassoWebhook');
+const widgets = require('./lib/widgets');
 const bodyParser = require('body-parser');
 
 const Plugin = {};
@@ -149,4 +150,8 @@ Plugin.emailModify = async function (data) {
   return data;
 };
 
+// Widgets
+Plugin.defineWidgets = widgets.defineWidgets;
+Plugin.renderTwoWeeksWidget = widgets.renderTwoWeeksWidget;
+
 module.exports = Plugin;

package/package.json

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

package/plugin.json

@@ -15,6 +15,14 @@
     {
       "hook": "filter:email.modify",
       "method": "emailModify"
+    },
+    {
+      "hook": "filter:widgets.getWidgets",
+      "method": "defineWidgets"
+    },
+    {
+      "hook": "filter:widget.render:calendar-onekite-twoweeks",
+      "method": "renderTwoWeeksWidget"
     }
   ],
   "staticDirs": {
@@ -31,5 +39,5 @@
   "acpScripts": [
     "public/admin.js"
   ],
-  "version": "1.0.1.1"
+  "version": "1.1.1"
 }

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

@@ -53,6 +53,31 @@
             <div class="form-text">Après validation (statut <code>paiement en attente</code>), un rappel est envoyé après ce délai. La réservation est ensuite expirée après <strong>2×</strong> ce délai.</div>
           </div>
 
+          <hr class="my-4" />
+          <h4>Discord</h4>
+
+          <div class="mb-3">
+            <label class="form-label">Webhook URL</label>
+            <input class="form-control" name="discordWebhookUrl" placeholder="https://discord.com/api/webhooks/...">
+            <div class="form-text">Si vide, aucune notification Discord n'est envoyée.</div>
+          </div>
+
+          <div class="mb-3">
+            <label class="form-label">Envoyer une notification à la demande</label>
+            <select class="form-select" name="discordNotifyOnRequest">
+              <option value="1">Oui</option>
+              <option value="0">Non</option>
+            </select>
+          </div>
+
+          <div class="mb-3">
+            <label class="form-label">Envoyer une notification au paiement reçu</label>
+            <select class="form-select" name="discordNotifyOnPaid">
+              <option value="1">Oui</option>
+              <option value="0">Non</option>
+            </select>
+          </div>
+
           <h4 class="mt-4">HelloAsso</h4>
 
           <div class="mb-3">