nodebb-plugin-ezoic-infinite 0.2.1 → 0.4.2

package/README.md

@@ -2,34 +2,20 @@
 
 Plugin NodeBB 4.x pour intégrer Ezoic lors des chargements en infinite scroll.
 
-## Installation (recommandée)
-Depuis le dossier NodeBB (où se trouve `package.json` du forum) :
+## Fonctionnalités
+- Pubs **entre posts** : toutes les N réponses, avec pool d'IDs (fenêtre glissante)
+- Pubs **type message** entre les réponses : toutes les M réponses, avec pool d'IDs séparé (fenêtre glissante)
+- Exclusion par groupes (ACP)
 
-### Option A — installer depuis un chemin local (simple)
+## Installation (local)
 ```bash
+cd /path/to/nodebb/node_modules
+unzip nodebb-plugin-ezoic-infinite.zip -d nodebb-plugin-ezoic-infinite
+cd /path/to/nodebb
 npm i ./node_modules/nodebb-plugin-ezoic-infinite
-# ou si tu as le dossier ailleurs : npm i /chemin/vers/nodebb-plugin-ezoic-infinite
 ./nodebb build
 ./nodebb restart
 ```
 
-### Option B — npm link (workflow dev)
-```bash
-cd node_modules/nodebb-plugin-ezoic-infinite
-npm link
-cd /usr/src/app   # dossier NodeBB
-npm link nodebb-plugin-ezoic-infinite
-./nodebb build
-./nodebb restart
-```
-
-> Note: NodeBB n’est généralement pas publié sur le registre npm, donc on **ne met pas** `nodebb` en dépendance npm “résoluble”.
 ## Configuration
 ACP -> Plugins -> Ezoic Infinite Ads
-- **Pool d’IDs**: un par ligne (ou séparé par virgules)
-- **Intervalle**: ex 6 (pub après #6, #12, #18, ...)
-- **Groupes exclus**: multi-sélection
-
-## Notes Ezoic
-Le plugin supprime les placeholders existants du DOM avant de les recréer, puis appelle
-`ezstandalone.destroyPlaceholders()` avant `ezstandalone.showAds(id)` afin d'éviter les doublons d'IDs.

package/library.js

@@ -10,7 +10,14 @@ const plugin = {};
 function normalizeExcludedGroups(value) {
   if (!value) return [];
   if (Array.isArray(value)) return value;
-  return value.split(',').map(s => s.trim()).filter(Boolean);
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
+
+function parseBool(v, def = false) {
+  if (v === undefined || v === null || v === '') return def;
+  if (typeof v === 'boolean') return v;
+  const s = String(v).toLowerCase();
+  return s === '1' || s === 'true' || s === 'on' || s === 'yes';
 }
 
 async function getAllGroups() {
@@ -22,8 +29,16 @@ async function getAllGroups() {
 async function getSettings() {
   const s = await meta.settings.get(SETTINGS_KEY);
   return {
+    // Between-post ads (simple blocks)
+    enableBetweenAds: parseBool(s.enableBetweenAds, true),
     placeholderIds: (s.placeholderIds || '').trim(),
     intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
+
+    // "Ad message" between replies (looks like a post)
+    enableMessageAds: parseBool(s.enableMessageAds, false),
+    messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
+    messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
+
     excludedGroups: normalizeExcludedGroups(s.excludedGroups),
   };
 }
@@ -31,7 +46,7 @@ async function getSettings() {
 async function isUserExcluded(uid, excludedGroups) {
   if (!uid || !excludedGroups.length) return false;
   const userGroups = await groups.getUserGroups([uid]);
-  return userGroups[0].some(g => excludedGroups.includes(g.name));
+  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
 }
 
 plugin.addAdminNavigation = async (header) => {
@@ -48,13 +63,31 @@ plugin.init = async ({ router, middleware }) => {
   router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, async (req, res) => {
     const settings = await getSettings();
     const allGroups = await getAllGroups();
-    res.render('admin/plugins/ezoic-infinite', { title: 'Ezoic Infinite Ads', ...settings, allGroups });
+
+    res.render('admin/plugins/ezoic-infinite', {
+      title: 'Ezoic Infinite Ads',
+      ...settings,
+      enableBetweenAds_checked: settings.enableBetweenAds ? 'checked' : '',
+      enableMessageAds_checked: settings.enableMessageAds ? 'checked' : '',
+      allGroups,
+    });
   });
 
   router.get('/api/plugins/ezoic-infinite/config', middleware.buildHeader, async (req, res) => {
     const settings = await getSettings();
     const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
-    res.json({ placeholderIds: settings.placeholderIds, intervalPosts: settings.intervalPosts, excluded });
+
+    res.json({
+      excluded,
+
+      enableBetweenAds: settings.enableBetweenAds,
+      placeholderIds: settings.placeholderIds,
+      intervalPosts: settings.intervalPosts,
+
+      enableMessageAds: settings.enableMessageAds,
+      messagePlaceholderIds: settings.messagePlaceholderIds,
+      messageIntervalPosts: settings.messageIntervalPosts,
+    });
   });
 };
 

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "0.2.1",
+  "version": "0.4.2",
   "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "main": "library.js",
+  "license": "MIT",
   "keywords": [
     "nodebb",
+    "nodebb-plugin",
     "ezoic",
-    "ads"
+    "ads",
+    "infinite-scroll"
   ],
-  "license": "MIT"
+  "engines": {
+    "node": ">=18"
+  }
 }

package/public/admin.js

@@ -1,35 +1,30 @@
-/* globals app, ajaxify, config */
+/* globals app, ajaxify */
 'use strict';
 
-function getCsrfToken() {
-  return (ajaxify?.data?.csrf_token) || (config?.csrf_token) || '';
-}
+(function () {
+  function isOurPage(data) {
+    const url = data?.url || ajaxify?.data?.url || window.location.pathname || '';
+    return url.includes('admin/plugins/ezoic-infinite') || url.includes('/plugins/ezoic-infinite');
+  }
 
-$(document).ready(() => {
-  $('#save').on('click', function (e) {
-    e.preventDefault();
+  function init() {
+    const $form = $('.ezoic-infinite-settings');
+    if (!$form.length) return;
 
-    const csrf = getCsrfToken();
-    if (!csrf) {
-      app.alertError('CSRF token introuvable');
-      return;
-    }
+    require(['settings'], function (Settings) {
+      Settings.load('ezoic-infinite', $form);
 
-    $.ajax({
-      method: 'PUT',
-      url: '/api/admin/settings/ezoic-infinite',
-      headers: {
-        'x-csrf-token': csrf
-      },
-      data: {
-        placeholderIds: $('#placeholderIds').val(),
-        intervalPosts: $('#intervalPosts').val(),
-        excludedGroups: ($('#excludedGroups').val() || []).join(',')
-      }
-    })
-    .done(() => app.alertSuccess('Paramètres enregistrés'))
-    .fail((xhr) => {
-      app.alertError(xhr?.responseJSON?.error || 'Erreur lors de la sauvegarde');
+      $('#save').off('click.ezoicInfinite').on('click.ezoicInfinite', function (e) {
+        e.preventDefault();
+        Settings.save('ezoic-infinite', $form, function () {
+          app.alertSuccess('Paramètres enregistrés');
+        });
+      });
     });
+  }
+
+  $(document).ready(init);
+  $(window).on('action:ajaxify.end', function (ev, data) {
+    if (isOurPage(data)) init();
   });
-});
+})();

package/public/client.js

@@ -14,38 +14,116 @@ async function fetchConfig() {
 }
 
 function parsePool(raw) {
+  if (!raw) return [];
   return Array.from(new Set(
     raw.split(/[\n,;\s]+/)
       .map(x => parseInt(x, 10))
-      .filter(n => n > 0)
+      .filter(n => Number.isFinite(n) && n > 0)
   ));
 }
 
-async function refreshAds() {
-  const cfg = await fetchConfig();
-  if (!cfg || cfg.excluded) return;
-
-  const pool = parsePool(cfg.placeholderIds);
-  const interval = cfg.intervalPosts;
-  const $posts = $('.posts .post');
-  if (!pool.length || !$posts.length) return;
+function isTopicPage() {
+  return ajaxify?.data?.template?.name === 'topic' || $('body').hasClass('page-topic');
+}
 
+function removePlaceholdersByPool(pool) {
   pool.forEach(id => $('#ezoic-pub-ad-placeholder-' + id).remove());
+}
 
-  const slots = Math.floor($posts.length / interval);
-  const start = Math.max(1, slots - pool.length + 1);
-  const activeIds = [];
+function removeAdMessageWrappers() {
+  $('.ezoic-ad-post').remove();
+}
+
+function computeWindowSlots(totalPosts, interval, poolSize) {
+  const slots = Math.floor(totalPosts / interval);
+  if (slots <= 0) return [];
+  const start = Math.max(1, slots - poolSize + 1);
+  const out = [];
+  for (let s = start; s <= slots; s++) out.push(s);
+  return out;
+}
+
+function insertBetweenPosts(pool, interval) {
+  if (!isTopicPage()) return [];
 
-  for (let slot = start, i = 0; slot <= slots; slot++, i++) {
+  const $posts = $('.posts .post').not('.ezoic-ad-post');
+  const total = $posts.length;
+  if (!total) return [];
+
+  const slotsToRender = computeWindowSlots(total, interval, pool.length);
+  if (!slotsToRender.length) return [];
+
+  const activeIds = [];
+  for (let i = 0; i < slotsToRender.length; i++) {
+    const slotNumber = slotsToRender[i];
     const id = pool[i];
-    const index = slot * interval - 1;
-    const $target = $posts.eq(index);
+    const postIndex = slotNumber * interval - 1;
+    const $target = $posts.eq(postIndex);
     if (!$target.length) continue;
+
     $target.after('<div id="ezoic-pub-ad-placeholder-' + id + '"></div>');
     activeIds.push(id);
   }
+  return activeIds;
+}
+
+function insertAdMessages(pool, interval) {
+  if (!isTopicPage()) return [];
+
+  const $posts = $('.posts .post').not('.ezoic-ad-post');
+  const total = $posts.length;
+  if (!total) return [];
+
+  const slotsToRender = computeWindowSlots(total, interval, pool.length);
+  if (!slotsToRender.length) return [];
+
+  const activeIds = [];
+  for (let i = 0; i < slotsToRender.length; i++) {
+    const slotNumber = slotsToRender[i];
+    const id = pool[i];
+    const postIndex = slotNumber * interval - 1;
+    const $target = $posts.eq(postIndex);
+    if (!$target.length) continue;
+
+    const html =
+      '<div class="post ezoic-ad-post" data-ezoic-ad="1">' +
+        '<div class="content">' +
+          '<div id="ezoic-pub-ad-placeholder-' + id + '"></div>' +
+        '</div>' +
+      '</div>';
+
+    $target.after(html);
+    activeIds.push(id);
+  }
+  return activeIds;
+}
+
+async function refreshAds() {
+  const cfg = await fetchConfig();
+  if (!cfg || cfg.excluded) return;
+  if (!isTopicPage()) return;
+
+  const betweenPool = parsePool(cfg.placeholderIds);
+  const betweenInterval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
+
+  const messagePool = parsePool(cfg.messagePlaceholderIds);
+  const messageInterval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
+
+  removeAdMessageWrappers();
+  removePlaceholdersByPool(betweenPool);
+  removePlaceholdersByPool(messagePool);
+
+  const activeIds = [];
+
+  if (cfg.enableBetweenAds && betweenPool.length) {
+    activeIds.push(...insertBetweenPosts(betweenPool, betweenInterval));
+  }
+
+  if (cfg.enableMessageAds && messagePool.length) {
+    activeIds.push(...insertAdMessages(messagePool, messageInterval));
+  }
 
-  if (window.ezstandalone?.destroyPlaceholders) {
+  if (activeIds.length && window.ezstandalone?.destroyPlaceholders) {
     window.ezstandalone.destroyPlaceholders();
   }
   activeIds.forEach(id => window.ezstandalone?.showAds?.(id));

package/public/templates/admin/plugins/ezoic-infinite.tpl

@@ -1,24 +1,59 @@
 <div class="acp-page-container">
   <h2>Ezoic Infinite Ads</h2>
 
-  <div class="mb-3">
-    <label class="form-label">Pool d’IDs Ezoic</label>
-    <textarea id="placeholderIds" class="form-control" rows="4">{placeholderIds}</textarea>
-  </div>
-
-  <div class="mb-3">
-    <label class="form-label">Afficher une pub tous les N posts</label>
-    <input type="number" id="intervalPosts" class="form-control" value="{intervalPosts}" min="1">
-  </div>
-
-  <div class="mb-3">
-    <label class="form-label">Groupes exclus</label>
-    <select id="excludedGroups" class="form-select" multiple>
-      <!-- BEGIN allGroups -->
-      <option value="{allGroups.name}">{allGroups.name}</option>
-      <!-- END allGroups -->
-    </select>
-  </div>
-
-  <button id="save" class="btn btn-primary">Enregistrer</button>
+  <form class="ezoic-infinite-settings" role="form">
+    <h4 class="mt-3">Pubs entre les posts (bloc simple)</h4>
+
+    <div class="form-check mb-3">
+      <input class="form-check-input" type="checkbox" id="enableBetweenAds" name="enableBetweenAds" {enableBetweenAds_checked}>
+      <label class="form-check-label" for="enableBetweenAds">Activer les pubs entre les posts</label>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="placeholderIds">Pool d’IDs Ezoic (entre posts)</label>
+      <textarea id="placeholderIds" name="placeholderIds" class="form-control" rows="4">{placeholderIds}</textarea>
+      <p class="form-text">Un ID par ligne (ou séparé par virgules/espaces). Le nombre d’IDs = nombre max de pubs simultanées.</p>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="intervalPosts">Afficher une pub tous les N posts</label>
+      <input type="number" id="intervalPosts" name="intervalPosts" class="form-control" value="{intervalPosts}" min="1">
+    </div>
+
+    <hr/>
+
+    <h4 class="mt-3">Pubs “message” entre les réponses</h4>
+    <p class="form-text">Insère un bloc qui ressemble à un post, toutes les N réponses (dans une page topic).</p>
+
+    <div class="form-check mb-3">
+      <input class="form-check-input" type="checkbox" id="enableMessageAds" name="enableMessageAds" {enableMessageAds_checked}>
+      <label class="form-check-label" for="enableMessageAds">Activer les pubs “message”</label>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="messagePlaceholderIds">Pool d’IDs Ezoic (message)</label>
+      <textarea id="messagePlaceholderIds" name="messagePlaceholderIds" class="form-control" rows="4">{messagePlaceholderIds}</textarea>
+      <p class="form-text">Pool séparé recommandé pour éviter la réutilisation d’IDs.</p>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="messageIntervalPosts">Afficher un “message pub” tous les N messages</label>
+      <input type="number" id="messageIntervalPosts" name="messageIntervalPosts" class="form-control" value="{messageIntervalPosts}" min="1">
+    </div>
+
+    <hr/>
+
+    <h4 class="mt-3">Exclusions</h4>
+    <div class="mb-3">
+      <label class="form-label" for="excludedGroups">Groupes exclus</label>
+      <select id="excludedGroups" name="excludedGroups" class="form-select" multiple>
+        <!-- BEGIN allGroups -->
+        <option value="{allGroups.name}">{allGroups.name}</option>
+        <!-- END allGroups -->
+      </select>
+      <p class="form-text">Si l’utilisateur appartient à un de ces groupes, aucune pub n’est injectée.</p>
+    </div>
+
+    <button id="save" class="btn btn-primary">Enregistrer</button>
+  </form>
 </div>