nodebb-plugin-onekite-calendar 2.0.11 → 2.0.13

package/pkg/package/lib/controllers.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const controllers = {};
+
+controllers.renderCalendar = async function (req, res) {
+  res.render('calendar-onekite', {
+    title: 'Calendar',
+  });
+};
+
+module.exports = controllers;

package/pkg/package/lib/db.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const db = require.main.require('./src/database');
+
+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}`;
+
+// Maintenance (simple ON/OFF per item, no dates)
+const KEY_MAINTENANCE_ZSET = 'calendar-onekite:maintenance:itemIds';
+
+// Audit log (partitioned by year)
+const KEY_AUDIT_ZSET = (year) => `calendar-onekite:audit:${year}`;
+const KEY_AUDIT_OBJ = (id) => `calendar-onekite:audit:entry:${id}`;
+
+// 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
+  await db.sortedSetAdd(KEY_ZSET, resv.start, resv.rid);
+  // Optional mapping to help reconcile HelloAsso webhooks that don't include metadata
+  if (resv.checkoutIntentId) {
+    try {
+      await db.setObjectField(KEY_CHECKOUT_INTENT_TO_RID, String(resv.checkoutIntentId), String(resv.rid));
+    } catch (e) {
+      // ignore
+    }
+  }
+}
+
+async function removeReservation(rid) {
+  await db.sortedSetRemove(KEY_ZSET, rid);
+  await db.delete(KEY_OBJ(rid));
+}
+
+async function listReservationIdsByStartRange(startTs, endTs, limit = 1000) {
+  // NodeBB db method name is getSortedSetRangeByScore(set, start, stop, min, max)
+  // (start/stop are index offsets, min/max are score range)
+  const start = 0;
+  const stop = Math.max(0, (parseInt(limit, 10) || 1000) - 1);
+  return await db.getSortedSetRangeByScore(KEY_ZSET, start, stop, startTs, endTs);
+}
+
+async function listAllReservationIds(limit = 5000) {
+  return await db.getSortedSetRange(KEY_ZSET, 0, limit - 1);
+}
+
+// --------------------
+// Maintenance
+// --------------------
+
+async function listMaintenanceItemIds(limit = 10000) {
+  return await db.getSortedSetRange(KEY_MAINTENANCE_ZSET, 0, Math.max(0, limit - 1));
+}
+
+async function isItemInMaintenance(itemId) {
+  if (!itemId) return false;
+  try {
+    // NodeBB DB returns 1/0 for isSortedSetMember
+    if (typeof db.isSortedSetMember === 'function') {
+      return !!(await db.isSortedSetMember(KEY_MAINTENANCE_ZSET, String(itemId)));
+    }
+  } catch (e) {}
+  const ids = await listMaintenanceItemIds(20000);
+  return Array.isArray(ids) ? ids.map(String).includes(String(itemId)) : false;
+}
+
+async function setItemMaintenance(itemId, enabled) {
+  const id = String(itemId || '').trim();
+  if (!id) return;
+  if (enabled) {
+    await db.sortedSetAdd(KEY_MAINTENANCE_ZSET, 0, id);
+  } else {
+    await db.sortedSetRemove(KEY_MAINTENANCE_ZSET, id);
+  }
+}
+
+async function setAllMaintenance(enabled, itemIds) {
+  // Clear set first (fast)
+  await db.delete(KEY_MAINTENANCE_ZSET);
+  if (!enabled) {
+    return { count: 0 };
+  }
+  const ids = Array.isArray(itemIds) ? itemIds.map(String).filter(Boolean) : [];
+  // Add back all ids
+  for (const id of ids) {
+    await db.sortedSetAdd(KEY_MAINTENANCE_ZSET, 0, id);
+  }
+  return { count: ids.length };
+}
+
+// --------------------
+// Audit
+// --------------------
+
+async function addAuditEntry(entry) {
+  const e = Object.assign({}, entry || {});
+  const ts = Number(e.ts) || Date.now();
+  const year = Number(e.year) || new Date(ts).getFullYear();
+  e.ts = ts;
+  e.year = year;
+  const id = e.id ? String(e.id) : `${ts}-${Math.random().toString(16).slice(2)}`;
+  e.id = id;
+  await db.setObject(KEY_AUDIT_OBJ(id), e);
+  await db.sortedSetAdd(KEY_AUDIT_ZSET(year), ts, id);
+  return e;
+}
+
+async function listAuditEntryIdsByYear(year, start = 0, stop = 200) {
+  const y = Number(year) || new Date().getFullYear();
+  return await db.getSortedSetRevRange(KEY_AUDIT_ZSET(y), start, stop);
+}
+
+async function getAuditEntriesByYear(year, limit = 200) {
+  const ids = await listAuditEntryIdsByYear(year, 0, Math.max(0, (Number(limit) || 200) - 1));
+  if (!ids || !ids.length) return [];
+  const keys = ids.map((id) => KEY_AUDIT_OBJ(id));
+  const rows = await db.getObjects(keys);
+  // Align with ids order
+  return (rows || []).map((row, idx) => row ? Object.assign({ id: String(ids[idx]) }, row) : null).filter(Boolean);
+}
+
+async function purgeAuditYear(year) {
+  const y = Number(year);
+  if (!y) return { ok: false, removed: 0 };
+  const ids = await db.getSortedSetRange(KEY_AUDIT_ZSET(y), 0, -1);
+  const keys = (ids || []).map((id) => KEY_AUDIT_OBJ(id));
+  if (keys.length) {
+    // Batch delete objects when possible
+    if (typeof db.deleteAll === 'function') {
+      await db.deleteAll(keys);
+    } else {
+      for (const k of keys) {
+        // eslint-disable-next-line no-await-in-loop
+        await db.delete(k);
+      }
+    }
+  }
+  await db.delete(KEY_AUDIT_ZSET(y));
+  return { ok: true, removed: (ids || []).length };
+}
+
+module.exports = {
+  KEY_ZSET,
+  KEY_SPECIAL_ZSET,
+  KEY_CHECKOUT_INTENT_TO_RID,
+  KEY_MAINTENANCE_ZSET,
+  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);
+  },
+  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,
+
+  // Maintenance
+  listMaintenanceItemIds,
+  isItemInMaintenance,
+  setItemMaintenance,
+  setAllMaintenance,
+
+  // Audit
+  addAuditEntry,
+  getAuditEntriesByYear,
+  purgeAuditYear,
+};

package/pkg/package/lib/discord.js

@@ -0,0 +1,190 @@
+'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,
+    '',
+    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');
+}
+
+function buildWebhookPayload(kind, reservation) {
+  // Discord "regroupe" visuellement les messages consécutifs d'un même auteur.
+  // En utilisant un username différent par action, on obtient un message bien distinct.
+  const webhookUsername = kind === 'paid'
+    ? 'Onekite • Paiement'
+    : (kind === 'cancelled' ? 'Onekite • Annulation' : 'Onekite • Réservation');
+
+  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'
+    : (kind === 'cancelled' ? '❌ Réservation annulée' : '⏳ Demande de réservation');
+
+  const fields = [];
+  if (username) {
+    fields.push({ name: 'Membre', value: username, inline: true });
+  }
+  if (items.length) {
+    const label = kind === 'request' ? 'Matériel demandé' : 'Matériel';
+    fields.push({ name: label, value: items.map((it) => `• ${it}`).join('\n'), inline: false });
+  }
+  if (Number.isFinite(start) && Number.isFinite(end)) {
+    fields.push({ name: 'Période', value: `Du ${formatFRShort(start)} au ${formatFRShort(end)}`, inline: false });
+  }
+
+  if (kind === 'cancelled') {
+    const cancelledAt = reservation && reservation.cancelledAt ? Number(reservation.cancelledAt) : NaN;
+    if (Number.isFinite(cancelledAt)) {
+      fields.push({ name: 'Annulée le', value: formatFRShort(cancelledAt), inline: true });
+    }
+  }
+
+  return {
+    username: webhookUsername,
+    // On laisse "content" vide pour privilégier l'embed (plus lisible sur Discord)
+    content: '',
+    embeds: [
+      {
+        title,
+        url: calUrl,
+        description: kind === 'paid'
+          ? 'Un paiement a été reçu pour une réservation.'
+          : (kind === 'cancelled'
+            ? 'Une réservation a été annulée.'
+            : 'Une nouvelle demande de réservation a été créée.'),
+        fields,
+        footer: { text: 'Onekite • Calendrier' },
+        timestamp: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+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, buildWebhookPayload('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, buildWebhookPayload('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));
+  }
+}
+
+async function notifyReservationCancelled(settings, reservation) {
+  const url = settings && settings.discordWebhookUrl ? String(settings.discordWebhookUrl).trim() : '';
+  if (!url) return;
+  if (!isEnabled(settings.discordNotifyOnCancelled, true)) return;
+
+  try {
+    await postWebhook(url, buildWebhookPayload('cancelled', reservation));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] Discord webhook failed (cancelled)', e && e.message ? e.message : String(e));
+  }
+}
+
+module.exports = {
+  notifyReservationRequested,
+  notifyPaymentReceived,
+  notifyReservationCancelled,
+};