nodebb-plugin-onekite-discord 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# nodebb-plugin-discord-onekite v1.1.4.19
+
+Fix: category names (and topic titles) are HTML-entity decoded before being used in Discord embeds.
+Example: `l'asso` -> `l'asso`.
+Supports French accents and special characters via numeric entity decoding.

package/lib/admin.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const meta = require.main.require('./src/meta');
+
+const SETTINGS_KEY = 'discord-onekite';
+
+function normalizeCids(v) {
+  if (!v) return [];
+  if (Array.isArray(v)) return v.map(String).filter(Boolean);
+  if (typeof v === 'string') return v.split(',').map(s => s.trim()).filter(Boolean);
+  return [];
+}
+
+async function getSettings() {
+  const s = await meta.settings.get(SETTINGS_KEY);
+  return {
+    webhookUrl: (s && s.webhookUrl) ? String(s.webhookUrl).trim() : '',
+    notifyReplies: !!(s && (s.notifyReplies === true || s.notifyReplies === 'on' || s.notifyReplies === 'true')),
+    cids: normalizeCids(s && s.cids),
+  };
+}
+
+async function saveSettings(body) {
+  const payload = {
+    webhookUrl: body.webhookUrl || '',
+    notifyReplies: body.notifyReplies ? 'on' : '',
+    // Store as CSV string for meta.settings
+    cids: Array.isArray(body.cids) ? body.cids.map(String).filter(Boolean).join(',') : (body.cids || ''),
+  };
+  await meta.settings.set(SETTINGS_KEY, payload);
+}
+
+module.exports = {
+  async getSettings(req, res) {
+    res.json({ settings: await getSettings() });
+  },
+  async saveSettings(req, res) {
+    await saveSettings(req.body || {});
+    res.json({ ok: true });
+  },
+};

package/lib/controllers.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const meta = require.main.require('./src/meta');
+const categories = require.main.require('./src/categories');
+
+const SETTINGS_KEY = 'discord-onekite';
+
+function normalizeCids(v) {
+  if (!v) return [];
+  if (Array.isArray(v)) return v.map(String).filter(Boolean);
+  if (typeof v === 'string') return v.split(',').map(s => s.trim()).filter(Boolean);
+  return [];
+}
+
+async function getReadableCategories(uid) {
+  return await new Promise((resolve) => {
+    categories.getCategoriesByPrivilege('categories:cid', uid || 0, 'read', (err, categoriesData) => {
+      if (err || !Array.isArray(categoriesData)) return resolve([]);
+      resolve(categoriesData.filter(Boolean));
+    });
+  });
+}
+
+const controllers = {};
+
+controllers.renderAdminPage = async function (req, res) {
+  const settings = await meta.settings.get(SETTINGS_KEY);
+  const savedCids = normalizeCids(settings && settings.cids);
+
+  const cats = await getReadableCategories(req.uid);
+  const categoriesForTpl = (cats || [])
+    .filter(c => c && typeof c.cid !== 'undefined' && c.name)
+    .map(c => ({
+      cid: String(c.cid),
+      name: c.name,
+      selected: savedCids.includes(String(c.cid)),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  res.render('admin/plugins/discord-onekite', {
+    settings: settings || {},
+    categories: categoriesForTpl,
+  });
+};
+
+module.exports = controllers;

package/library.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const { request } = require('undici');
+
+const routeHelpers = require.main.require('./src/routes/helpers');
+const meta = require.main.require('./src/meta');
+
+const topics = require.main.require('./src/topics');
+const categories = require.main.require('./src/categories');
+const posts = require.main.require('./src/posts');
+
+const controllers = require('./lib/controllers');
+const adminApi = require('./lib/admin');
+
+const Plugin = {};
+
+const SETTINGS_KEY = 'discord-onekite';
+
+function normalizeCids(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map(v => String(v)).filter(Boolean);
+  if (typeof value === 'string') return value.split(',').map(s => s.trim()).filter(Boolean);
+  return [];
+}
+
+function normalizeBaseUrl(url) {
+  if (!url) return '';
+  let s = String(url).trim();
+  if (!/^https?:\/\//i.test(s)) s = `https://${s}`;
+  s = s.replace(/\/+$/, '');
+  return s;
+}
+
+function ensureAbsoluteUrl(baseUrl, maybeUrl) {
+  if (!maybeUrl) return '';
+  const s = String(maybeUrl);
+  if (/^https?:\/\//i.test(s)) return s;
+  if (s.startsWith('//')) return `https:${s}`;
+  if (s.startsWith('/')) return `${baseUrl}${s}`;
+  return s;
+}
+
+function stripHtml(html) {
+  if (!html) return '';
+  return String(html)
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n')
+    .replace(/<[^>]*>/g, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&#39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .trim();
+}
+
+
+function decodeHtmlEntities(input) {
+  if (!input) return '';
+  let s = String(input);
+
+  // Named entities commonly encountered
+  s = s
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'");
+
+  // Decimal numeric entities
+  s = s.replace(/&#(\d+);/g, (m, dec) => {
+    const code = parseInt(dec, 10);
+    if (!Number.isFinite(code)) return m;
+    return String.fromCodePoint(code);
+  });
+
+  // Hex numeric entities
+  s = s.replace(/&#x([0-9a-fA-F]+);/g, (m, hex) => {
+    const code = parseInt(hex, 16);
+    if (!Number.isFinite(code)) return m;
+    return String.fromCodePoint(code);
+  });
+
+  return s;
+}
+
+function truncate(s, n) {
+  const str = String(s || '');
+  if (str.length <= n) return str;
+  return str.slice(0, n - 1) + '…';
+}
+
+async function getSettings() {
+  const s = await meta.settings.get(SETTINGS_KEY);
+  return {
+    webhookUrl: (s && s.webhookUrl) ? String(s.webhookUrl).trim() : '',
+    notifyReplies: !!(s && (s.notifyReplies === true || s.notifyReplies === 'on' || s.notifyReplies === 'true')),
+    cids: normalizeCids(s && s.cids),
+  };
+}
+
+function cidAllowed(topicCid, allowedCids) {
+  if (!allowedCids || allowedCids.length === 0) return true;
+  return allowedCids.includes(String(topicCid));
+}
+
+async function postToDiscord(webhookUrl, payload) {
+  const res = await request(webhookUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  const bodyText = await res.body.text().catch(() => '');
+
+  if (res.statusCode < 200 || res.statusCode >= 300) {
+    const err = new Error(`[discord-onekite] Discord webhook HTTP ${res.statusCode}: ${bodyText}`);
+    err.statusCode = res.statusCode;
+    err.responseBody = bodyText;
+    throw err;
+  }
+}
+
+async function sendDiscord(webhookUrl, payload) {
+  if (!webhookUrl) return;
+  try {
+    await postToDiscord(webhookUrl, payload);
+  } catch (e) {
+    // fallback to plain content if embeds rejected
+    if (e && e.statusCode === 400 && payload && payload.embeds) {
+      const fallback = payload.embeds[0] && payload.embeds[0].description ? payload.embeds[0].description : 'Notification';
+      try { await postToDiscord(webhookUrl, { content: fallback }); return; } catch (e2) { console.error(e2); }
+    }
+    console.error(e);
+  }
+}
+
+async function getPostExcerpt(pid) {
+  if (!pid) return '';
+  try {
+    const p = await posts.getPostFields(pid, ['content']);
+    const text = stripHtml(p && p.content);
+    return truncate(text, 500);
+  } catch {
+    return '';
+  }
+}
+
+async function buildEmbed({ tid, pid, isReply }) {
+  let baseUrl = normalizeBaseUrl(meta.config.url || meta.config['url']);
+  if (!baseUrl) baseUrl = 'https://www.onekite.com';
+
+  const topicData = await topics.getTopicFields(tid, ['tid', 'cid', 'title', 'slug', 'mainPid']);
+  if (!topicData) return null;
+
+  let categoryName = '';
+  try {
+    const cat = await categories.getCategoryData(topicData.cid);
+    if (cat && cat.name) categoryName = decodeHtmlEntities(cat.name);
+  } catch (e) {}
+
+  const topicUrl = ensureAbsoluteUrl(baseUrl, `/topic/${topicData.slug || topicData.tid}`);
+  const targetUrl = (isReply && pid) ? `${topicUrl}/${pid}` : topicUrl;
+
+  const baseTitle = decodeHtmlEntities((topicData.title || (isReply ? 'Nouvelle réponse' : 'Nouveau sujet')).toString());
+  const title = categoryName ? `[${categoryName}] ${baseTitle}` : baseTitle;
+  const safeTitle = title.slice(0, 256);
+
+  const excerpt = await getPostExcerpt(isReply ? pid : topicData.mainPid);
+
+  return { topicData, embed: { title: safeTitle, url: targetUrl, description: excerpt || '' } };
+}
+
+function extractTidPid(data) {
+  const tid = data?.tid || data?.topic?.tid || data?.post?.tid;
+  const pid = data?.pid || data?.post?.pid;
+  return { tid, pid };
+}
+
+Plugin.init = async function (params) {
+  const { router, middleware } = params;
+
+  // ACP page
+  routeHelpers.setupAdminPageRoute(router, '/admin/plugins/discord-onekite', [], controllers.renderAdminPage);
+
+  // Admin API v3 routes (same pattern as calendar-onekite)
+  const adminBases = ['/api/v3/admin/plugins/discord-onekite'];
+  const adminMws = [middleware.admin.checkPrivileges];
+
+  adminBases.forEach((base) => {
+    router.get(`${base}/settings`, ...adminMws, adminApi.getSettings);
+    router.put(`${base}/settings`, ...adminMws, adminApi.saveSettings);
+  });
+};
+
+Plugin.addAdminNavigation = (header) => {
+  header.plugins.push({
+    route: '/plugins/discord-onekite',
+    icon: 'fa-bell',
+    name: 'Discord Onekite',
+  });
+  return header;
+};
+
+Plugin.onTopicPost = async (data) => {
+  const settings = await getSettings();
+  if (!settings.webhookUrl) return;
+
+  const { tid } = extractTidPid(data);
+  if (!tid) return;
+
+  const built = await buildEmbed({ tid, isReply: false });
+  if (!built) return;
+  if (!cidAllowed(built.topicData.cid, settings.cids)) return;
+
+  await sendDiscord(settings.webhookUrl, { embeds: [built.embed] });
+};
+
+Plugin.onTopicReply = async (data) => {
+  const settings = await getSettings();
+  if (!settings.notifyReplies) return;
+  if (!settings.webhookUrl) return;
+
+  const { tid, pid } = extractTidPid(data);
+  if (!tid || !pid) return;
+
+  const built = await buildEmbed({ tid, pid, isReply: true });
+  if (!built) return;
+  if (!cidAllowed(built.topicData.cid, settings.cids)) return;
+
+  await sendDiscord(settings.webhookUrl, { embeds: [built.embed] });
+};
+
+module.exports = Plugin;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nodebb-plugin-onekite-discord",
+  "version": "1.0.0",
+  "description": "Discord webhook notifier for Onekite (NodeBB v4.x only)",
+  "main": "library.js",
+  "license": "MIT",
+  "keywords": [
+    "nodebb",
+    "plugin",
+    "discord",
+    "webhook",
+    "notifications"
+  ],
+  "dependencies": {
+    "undici": "^6.0.0"
+  },
+  "nbbpm": {
+    "compatibility": "^4.0.0"
+  }
+}

package/plugin.json

@@ -0,0 +1,36 @@
+{
+  "id": "nodebb-plugin-onekite-discord",
+  "name": "Discord Onekite Notifier",
+  "description": "Notifie Discord via webhook pour nouveaux sujets et/ou r\u00e9ponses (NodeBB v4.x).",
+  "library": "./library.js",
+  "hooks": [
+    {
+      "hook": "static:app.load",
+      "method": "init"
+    },
+    {
+      "hook": "filter:admin.header.build",
+      "method": "addAdminNavigation"
+    },
+    {
+      "hook": "action:topic.post",
+      "method": "onTopicPost"
+    },
+    {
+      "hook": "action:topic.reply",
+      "method": "onTopicReply"
+    }
+  ],
+  "staticDirs": {
+    "public": "./public"
+  },
+  "templates": "./templates",
+  "modules": {
+    "../admin/plugins/discord-onekite.js": "./public/admin.js",
+    "admin/plugins/discord-onekite": "./public/admin.js"
+  },
+  "acpScripts": [
+    "public/admin.js"
+  ],
+  "version": "1.1.4.19"
+}

package/public/admin.js

@@ -0,0 +1,118 @@
+define('admin/plugins/discord-onekite', ['alerts', 'bootbox'], function (alerts) {
+  'use strict';
+
+  function showAlert(type, msg) {
+    // Deduplicate identical alerts that can be triggered multiple times
+    // by NodeBB ACP save buttons/hooks across ajaxify navigations.
+    try {
+      const now = Date.now();
+      const last = window.oneKiteDiscordLastAlert;
+      if (last && last.type === type && last.msg === msg && (now - last.ts) < 1200) {
+        return;
+      }
+      window.oneKiteDiscordLastAlert = { type, msg, ts: now };
+    } catch (e) {}
+    try {
+      if (alerts && typeof alerts[type] === 'function') {
+        alerts[type](msg);
+        return;
+      }
+    } catch (e) {}
+    alert(msg);
+  }
+
+  async function fetchJson(url, opts) {
+    const res = await fetch(url, Object.assign({
+      headers: Object.assign({
+        'Content-Type': 'application/json',
+        'x-csrf-token': (document.querySelector('meta[name="csrf_token"]') && document.querySelector('meta[name="csrf_token"]').getAttribute('content')) ||
+          (document.querySelector('meta[name="csrf-token"]') && document.querySelector('meta[name="csrf-token"]').getAttribute('content')) ||
+          (typeof app !== 'undefined' && app && app.csrfToken) ||
+          '',
+      }, (opts && opts.headers) || {}),
+      credentials: 'same-origin',
+    }, opts || {}));
+
+    const text = await res.text();
+    let data = null;
+    try { data = text ? JSON.parse(text) : null; } catch (e) {}
+
+    if (!res.ok) {
+      const err = new Error((data && data.status && data.status.message) || text || 'Request failed');
+      err.status = res.status;
+      err.data = data;
+      throw err;
+    }
+    return data;
+  }
+
+  async function loadSettings() {
+    const data = await fetchJson('/api/v3/admin/plugins/discord-onekite/settings');
+    return (data && data.settings) ? data.settings : {};
+  }
+
+  async function saveSettings(payload) {
+    return await fetchJson('/api/v3/admin/plugins/discord-onekite/settings', {
+      method: 'PUT',
+      body: JSON.stringify(payload),
+    });
+  }
+
+  function getSelectedCids() {
+    return Array.from(document.querySelectorAll('#cidsMulti option:checked')).map(o => String(o.value));
+  }
+
+  function setSelectedCids(cids) {
+    const set = new Set((cids || []).map(String));
+    document.querySelectorAll('#cidsMulti option').forEach(opt => {
+      opt.selected = set.has(String(opt.value));
+    });
+  }
+
+  function getPayload() {
+    return {
+      webhookUrl: String(document.getElementById('webhookUrl')?.value || '').trim(),
+      notifyReplies: !!document.getElementById('notifyReplies')?.checked,
+      cids: getSelectedCids(),
+    };
+  }
+
+  async function doSave() {
+    try {
+      await saveSettings(getPayload());
+      showAlert('success', 'Paramètres enregistrés');
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+      showAlert('error', e && e.message ? e.message : 'Erreur lors de l’enregistrement');
+    }
+  }
+
+  function bindSaveButtons() {
+    const SAVE_SELECTOR = '#save, .save, [data-action="save"], .settings-save, .floating-save, .btn[data-action="save"], #onekite-save, #save-top, #onekite-discord-save';
+    if (window.oneKiteDiscordAdminBound) return;
+    window.oneKiteDiscordAdminBound = true;
+
+    document.addEventListener('click', function (ev) {
+      const target = ev.target && (ev.target.closest ? ev.target.closest(SAVE_SELECTOR) : null);
+      if (!target) return;
+      ev.preventDefault();
+      doSave();
+    }, true);
+  }
+
+  async function init() {
+    bindSaveButtons();
+    try {
+      const s = await loadSettings();
+      if (typeof s.webhookUrl !== 'undefined') document.getElementById('webhookUrl').value = s.webhookUrl || '';
+      if (typeof s.notifyReplies !== 'undefined') document.getElementById('notifyReplies').checked = !!s.notifyReplies;
+      if (Array.isArray(s.cids)) setSelectedCids(s.cids);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+    }
+  }
+
+  return { init: init };
+});

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

@@ -0,0 +1,41 @@
+<div class="acp-page-container">
+  <div class="d-flex justify-content-between align-items-start mb-3">
+    <div>
+      <h4 class="mb-1">Discord Onekite</h4>
+      <p class="text-muted mb-0">Notifications Discord via webhook.</p>
+    </div>
+    <button class="btn btn-primary" id="onekite-discord-save" type="button">Enregistrer</button>
+  </div>
+
+  <div class="row">
+    <div class="col-lg-8">
+      <div class="card mb-3">
+        <div class="card-body">
+          <form class="discord-onekite-settings" role="form">
+            <div class="mb-3">
+              <label class="form-label" for="webhookUrl">Discord Webhook URL</label>
+              <input id="webhookUrl" type="text" class="form-control" placeholder="https://discord.com/api/webhooks/..." value="{settings.webhookUrl}" />
+            </div>
+
+            <div class="form-check mb-3">
+              <input class="form-check-input" type="checkbox" id="notifyReplies" <!-- IF settings.notifyReplies -->checked<!-- ENDIF settings.notifyReplies -->>
+              <label class="form-check-label" for="notifyReplies">Notifier aussi les réponses</label>
+            </div>
+
+            <div class="mb-3">
+              <label class="form-label" for="cidsMulti">Catégories à notifier</label>
+              <select class="form-select" id="cidsMulti" multiple size="12">
+                <!-- BEGIN categories -->
+                <option value="{categories.cid}" <!-- IF categories.selected -->selected<!-- ENDIF categories.selected -->>{categories.name}</option>
+                <!-- END categories -->
+              </select>
+              <p class="form-text text-muted">
+                Si aucune catégorie n’est sélectionnée : <strong>toutes les catégories</strong> seront notifiées.
+              </p>
+            </div>
+          </form>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>