nodebb-plugin-ezoic-infinite 1.0.3 → 1.0.6

package/library.js

@@ -1,50 +1,100 @@
-
 'use strict';
 
 const meta = require.main.require('./src/meta');
 const groups = require.main.require('./src/groups');
+const db = require.main.require('./src/database');
 
-const Plugin = {};
-
-Plugin.init = async ({ router, middleware }) => {
-  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
-  router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
-};
+const SETTINGS_KEY = 'ezoic-infinite';
+const plugin = {};
 
-async function renderAdmin(req, res) {
-  const settings = await meta.settings.get('ezoic-infinite');
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
 
-  let groupNames = [];
-  try {
-    groupNames = await groups.getGroupsFromSet('groups:createtime', 0, -1);
-  } catch (e) {}
+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';
+}
 
-  let groupList = [];
-  try {
-    groupList = await groups.getGroupsData(groupNames);
-  } catch (e) {
-    groupList = groupNames.map(name => ({ name }));
+async function getAllGroups() {
+  let names = await db.getSortedSetRange('groups:createtime', 0, -1);
+  if (!names || !names.length) {
+    names = await db.getSortedSetRange('groups:visible:createtime', 0, -1);
   }
+  const filtered = names.filter(name => !groups.isPrivilegeGroup(name));
+  const data = await groups.getGroupsData(filtered);
+  // Sort alphabetically for ACP usability
+  data.sort((a, b) => String(a.name).localeCompare(String(b.name), 'fr', { sensitivity: 'base' }));
+  return data;
+}
+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),
 
-  res.render('admin/plugins/ezoic-infinite', {
-    settings,
-    groups: groupList,
-  });
+    // "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),
+  };
 }
 
-Plugin.addAdminNavigation = async (header) => {
+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));
+}
+
+plugin.addAdminNavigation = async (header) => {
   header.plugins = header.plugins || [];
   header.plugins.push({
     route: '/plugins/ezoic-infinite',
-    icon: 'fa-bullhorn',
-    name: 'Ezoic Infinite',
+    icon: 'fa-ad',
+    name: 'Ezoic Infinite Ads'
   });
   return header;
 };
 
-Plugin.addConfig = async (config) => {
-  config.ezoicInfinite = await meta.settings.get('ezoic-infinite');
-  return config;
+plugin.init = async ({ router, middleware }) => {
+  async function render(req, res) {
+    const settings = await getSettings();
+    const allGroups = await getAllGroups();
+
+    res.render('admin/plugins/ezoic-infinite', {
+      title: 'Ezoic Infinite Ads',
+      ...settings,
+      enableBetweenAds_checked: settings.enableBetweenAds ? 'checked' : '',
+      enableMessageAds_checked: settings.enableMessageAds ? 'checked' : '',
+      allGroups,
+    });
+  }
+
+  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
+  router.get('/api/admin/plugins/ezoic-infinite', render);
+
+  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({
+      excluded,
+      enableBetweenAds: settings.enableBetweenAds,
+      placeholderIds: settings.placeholderIds,
+      intervalPosts: settings.intervalPosts,
+      enableMessageAds: settings.enableMessageAds,
+      messagePlaceholderIds: settings.messagePlaceholderIds,
+      messageIntervalPosts: settings.messageIntervalPosts,
+    });
+  });
 };
 
-module.exports = Plugin;
+module.exports = plugin;

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.0.3",
-  "description": "Ezoic Infinite (rollback to 0.8.2 behaviour)",
+  "version": "1.0.6",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "main": "library.js",
   "license": "MIT",
+  "keywords": [
+    "nodebb",
+    "nodebb-plugin",
+    "ezoic",
+    "ads",
+    "infinite-scroll"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "nbbpm": {
     "compatibility": "^4.0.0"
   }

package/plugin.json

@@ -1,6 +1,7 @@
 {
   "id": "nodebb-plugin-ezoic-infinite",
-  "name": "Ezoic Infinite",
+  "name": "NodeBB Ezoic Infinite Ads",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "library": "./library.js",
   "hooks": [
     {
@@ -10,10 +11,6 @@
     {
       "hook": "filter:admin.header.build",
       "method": "addAdminNavigation"
-    },
-    {
-      "hook": "filter:config.get",
-      "method": "addConfig"
     }
   ],
   "staticDirs": {
@@ -25,5 +22,8 @@
   "scripts": [
     "public/client.js"
   ],
-  "templates": "public/templates"
+  "templates": "public/templates",
+  "css": [
+    "public/style.css"
+  ]
 }

package/public/admin.js

@@ -1,35 +1,29 @@
+/* globals ajaxify */
+'use strict';
 
-/* global $, socket, app */
-$(function () {
-  const ns = 'ezoic-infinite';
-  const form = $('.ezoic-infinite-settings');
+(function () {
+  function init() {
+    const $form = $('.ezoic-infinite-settings');
+    if (!$form.length) return;
 
-  socket.emit('admin.settings.get', { hash: ns }, (err, data) => {
-    if (!data) return;
-    Object.keys(data).forEach(k => {
-      const el = form.find('[name="' + k + '"]');
-      if (!el.length) return;
-      if (el.attr('type') === 'checkbox') el.prop('checked', data[k]);
-      else el.val(data[k]);
-    });
-
-    if (data.excludedGroups) {
-      data.excludedGroups.split(',').forEach(g =>
-        form.find('option[value="' + g + '"]').prop('selected', true)
-      );
-    }
-  });
+    require(['settings', 'alerts'], function (Settings, alerts) {
+      Settings.load('ezoic-infinite', $form);
 
-  $('.ezoic-save').on('click', () => {
-    const values = {};
-    form.serializeArray().forEach(o => values[o.name] = o.value);
-    values.enableBetweenAds = form.find('[name=enableBetweenAds]').is(':checked');
-    values.enableMessageAds = form.find('[name=enableMessageAds]').is(':checked');
-    values.excludedGroups = (form.find('[name=excludedGroups]').val() || []).join(',');
+      $('#save').off('click.ezoicInfinite').on('click.ezoicInfinite', function (e) {
+        e.preventDefault();
 
-    socket.emit('admin.settings.set', { hash: ns, values }, err => {
-      if (err) app.alertError(err.message);
-      else app.alertSuccess('Enregistré');
+        Settings.save('ezoic-infinite', $form, function () {
+          // Toast vert (NodeBB core)
+          if (alerts && typeof alerts.success === 'function') {
+            alerts.success('Enregistré');
+          } else if (window.app && typeof window.app.alertSuccess === 'function') {
+            window.app.alertSuccess('Enregistré');
+          }
+        });
+      });
     });
-  });
-});
+  }
+
+  $(document).ready(init);
+  $(window).on('action:ajaxify.end', init);
+})();

package/public/client.js

@@ -1,6 +1,259 @@
+'use strict';
 
-/* global config */
+/* globals ajaxify */
 (function () {
-  if (!config || !config.ezoicInfinite) return;
-  // Same logic as stable 0.8.x
+  if (window.ezoicInfiniteLoaded) return;
+  window.ezoicInfiniteLoaded = true;
+
+  let cachedConfig;
+  let lastFetch = 0;
+  let debounceTimer;
+
+  let inFlight = false;
+  let rerunRequested = false;
+
+  // per page state
+  let pageKey = null;
+
+  // separate pools/state
+  let usedBetween = new Set();  // between topics list
+  let usedMessage = new Set();  // between replies
+  let fifoBetween = [];
+  let fifoMessage = [];
+
+  function getPageKey() {
+    try {
+      if (ajaxify && ajaxify.data) {
+        if (ajaxify.data.tid) return 'topic:' + ajaxify.data.tid;
+        if (ajaxify.data.cid) return 'cid:' + ajaxify.data.cid + ':' + window.location.pathname;
+      }
+    } catch (e) {}
+    return window.location.pathname;
+  }
+
+  function isTopicPage() {
+    try { return !!(ajaxify && ajaxify.data && ajaxify.data.tid); } catch (e) {}
+    return /^\/topic\//.test(window.location.pathname);
+  }
+
+  function isCategoryTopicList() {
+    return document.querySelectorAll('li[component="category/topic"]').length > 0 && !isTopicPage();
+  }
+
+  function parsePool(raw) {
+    if (!raw) return [];
+    // accept newline, comma, space, semicolon
+    const arr = String(raw).split(/[\n,;\s]+/)
+      .map(x => parseInt(x, 10))
+      .filter(n => Number.isFinite(n) && n > 0);
+    // unique while preserving order
+    return Array.from(new Set(arr));
+  }
+
+  async function fetchConfig() {
+    if (cachedConfig && Date.now() - lastFetch < 10000) return cachedConfig;
+    const base = (window.config && window.config.relative_path) ? window.config.relative_path : '';
+    const res = await fetch(base + '/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+    const json = await res.json();
+    cachedConfig = json;
+    lastFetch = Date.now();
+    return json;
+  }
+
+  function cleanupForNewPage() {
+    document.querySelectorAll('.ezoic-ad').forEach(el => el.remove());
+    usedBetween = new Set();
+    usedMessage = new Set();
+    fifoBetween = [];
+    fifoMessage = [];
+  }
+
+  function destroyPlaceholder(id) {
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
+        window.ezstandalone.destroyPlaceholders(id);
+        return;
+      }
+      window.ezstandalone.cmd.push(function () {
+        try { window.ezstandalone.destroyPlaceholders(id); } catch (e) {}
+      });
+    } catch (e) {}
+  }
+
+  function ensureUniquePlaceholder(id) {
+    const existing = document.getElementById('ezoic-pub-ad-placeholder-' + id);
+    if (!existing) return;
+    const wrap = existing.closest('.ezoic-ad');
+    if (wrap) wrap.remove();
+    else existing.remove();
+    destroyPlaceholder(id);
+  }
+
+  function callShowAdsSingle(id) {
+    if (!id) return;
+
+    const now = Date.now();
+    window.__ezoicLastSingle = window.__ezoicLastSingle || {};
+    const last = window.__ezoicLastSingle[id] || 0;
+    if (now - last < 1200) return;
+    window.__ezoicLastSingle[id] = now;
+
+    window.ezstandalone = window.ezstandalone || {};
+    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+
+    const run = function () {
+      try {
+        if (typeof window.ezstandalone.showAds === 'function') {
+          window.ezstandalone.showAds(id);
+          return true;
+        }
+      } catch (e) {}
+      return false;
+    };
+
+    window.ezstandalone.cmd.push(function () { run(); });
+
+    let tries = 0;
+    (function tick() {
+      tries++;
+      if (run() || tries >= 8) return;
+      setTimeout(tick, 800);
+    })();
+  }
+
+  function pickNextId(pool, usedSet) {
+    for (const id of pool) if (!usedSet.has(id)) return id;
+    return null;
+  }
+
+  function recycle(fifo, usedSet, selector) {
+    fifo.sort((a, b) => a.after - b.after);
+    while (fifo.length) {
+      const old = fifo.shift();
+      const el = document.querySelector(selector(old));
+      if (!el) continue;
+      el.remove();
+      usedSet.delete(old.id);
+      destroyPlaceholder(old.id);
+      return old.id;
+    }
+    return null;
+  }
+
+  function insertAfter(targetEl, id, cls, afterVal) {
+    ensureUniquePlaceholder(id);
+    const wrap = document.createElement('div');
+    wrap.className = 'ezoic-ad ' + cls;
+    wrap.setAttribute('data-ezoic-id', String(id));
+    wrap.setAttribute('data-ezoic-after', String(afterVal));
+    wrap.innerHTML = '<div class="ezoic-ad-inner"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>';
+    targetEl.insertAdjacentElement('afterend', wrap);
+  }
+
+  function injectBetweenTopics(cfg) {
+    if (!cfg.enableBetweenAds) return;
+    const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
+    const pool = parsePool(cfg.placeholderIds);
+    if (!pool.length) return;
+
+    const items = Array.from(document.querySelectorAll('li[component="category/topic"]'));
+    if (!items.length) return;
+
+    items.forEach((li, idx) => {
+      const pos = idx + 1;
+      if (pos % interval !== 0) return;
+      if (idx === items.length - 1) return;
+
+      const next = li.nextElementSibling;
+      if (next && next.classList && next.classList.contains('ezoic-ad-between')) return;
+
+      let id = pickNextId(pool, usedBetween);
+      if (!id) {
+        id = recycle(fifoBetween, usedBetween, (old) => '.ezoic-ad-between[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
+        if (!id) return; // pool empty and nothing recyclable => stop
+      }
+
+      usedBetween.add(id);
+      fifoBetween.push({ id, after: pos });
+
+      insertAfter(li, id, 'ezoic-ad-between', pos);
+      callShowAdsSingle(id);
+    });
+  }
+
+  function injectBetweenMessages(cfg) {
+    if (!cfg.enableMessageAds) return;
+    const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
+    const pool = parsePool(cfg.messagePlaceholderIds);
+    if (!pool.length) return;
+
+    const posts = Array.from(document.querySelectorAll('[component="post"][data-pid]'));
+    if (!posts.length) return;
+
+    posts.forEach((post, idx) => {
+      const no = idx + 1;
+      if (no % interval !== 0) return;
+      if (idx === posts.length - 1) return;
+
+      const next = post.nextElementSibling;
+      if (next && next.classList && next.classList.contains('ezoic-ad-message')) return;
+
+      let id = pickNextId(pool, usedMessage);
+      if (!id) {
+        id = recycle(fifoMessage, usedMessage, (old) => '.ezoic-ad-message[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
+        if (!id) return;
+      }
+
+      usedMessage.add(id);
+      fifoMessage.push({ id, after: no });
+
+      insertAfter(post, id, 'ezoic-ad-message', no);
+      callShowAdsSingle(id);
+    });
+  }
+
+  async function run() {
+    if (inFlight) { rerunRequested = true; return; }
+    inFlight = true;
+
+    try {
+      const key = getPageKey();
+      if (pageKey !== key) {
+        pageKey = key;
+        cleanupForNewPage();
+      }
+
+      const cfg = await fetchConfig();
+      if (!cfg || cfg.excluded) return;
+
+      if (isTopicPage()) injectBetweenMessages(cfg);
+      else if (isCategoryTopicList()) injectBetweenTopics(cfg);
+    } catch (e) {
+      // silent
+    } finally {
+      inFlight = false;
+      if (rerunRequested) {
+        rerunRequested = false;
+        setTimeout(run, 50);
+      }
+    }
+  }
+
+  function scheduleRun() {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(run, 150);
+  }
+
+  document.addEventListener('DOMContentLoaded', function () {
+    run();
+    setTimeout(run, 1200);
+  });
+
+  window.addEventListener('action:ajaxify.end', scheduleRun);
+  window.addEventListener('action:posts.loaded', scheduleRun);
+  window.addEventListener('action:topic.loaded', scheduleRun);
+  window.addEventListener('action:topics.loaded', scheduleRun);
+  window.addEventListener('action:category.loaded', scheduleRun);
 })();

package/public/style.css

@@ -0,0 +1,3 @@
+.ezoic-ad{height:auto !important; min-height:0 !important; padding:0 !important; margin:0.5rem 0;}
+.ezoic-ad .ezoic-ad-inner{padding:0;margin:0;}
+.ezoic-ad .ezoic-ad-inner > div{padding:0;margin:0;}

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

@@ -1,78 +1,59 @@
-<div class="row">
-  <div class="col-lg-9">
-    <div class="card">
-      <div class="card-header">
-        <strong>Ezoic Infinite</strong>
-      </div>
-      <div class="card-body">
-        <form class="ezoic-infinite-settings">
-          <div class="mb-3">
-            <label class="form-label">Groupes exclus</label>
-            <select multiple class="form-control" name="excludedGroups" size="8">
-              <!-- BEGIN groups -->
-              <option value="{groups.name}">{groups.name}</option>
-              <!-- END groups -->
-            </select>
-            <p class="form-text">Aucune publicité ne sera affichée pour ces groupes.</p>
-          </div>
+<div class="acp-page-container">
+  <h2>Ezoic - Publicités Infinite Scroll Ads</h2>
 
-          <hr />
+  <form class="ezoic-infinite-settings" role="form">
+    <h4 class="mt-3">Pubs entre les posts (bloc simple)</h4>
 
-          <h5>Publicités entre les topics (liste des sujets)</h5>
-
-          <div class="form-check mb-3">
-            <input class="form-check-input" type="checkbox" name="enableBetweenAds" id="enableBetweenAds">
-            <label class="form-check-label" for="enableBetweenAds">Activer</label>
-          </div>
-
-          <div class="mb-3">
-            <label class="form-label">Intervalle (après chaque N topics)</label>
-            <input type="number" class="form-control" name="intervalTopics" min="1" step="1">
-          </div>
+    <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">Pool d'IDs placeholder (un par ligne)</label>
-            <textarea class="form-control" name="placeholderIds" rows="5"></textarea>
-          </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>
 
-          <hr />
+    <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>
 
-          <h5>Publicités entre les messages (dans un topic)</h5>
+    <hr/>
 
-          <div class="form-check mb-3">
-            <input class="form-check-input" type="checkbox" name="enableMessageAds" id="enableMessageAds">
-            <label class="form-check-label" for="enableMessageAds">Activer</label>
-          </div>
+    <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="mb-3">
-            <label class="form-label">Intervalle (après chaque N messages)</label>
-            <input type="number" class="form-control" name="messageIntervalPosts" min="1" step="1">
-          </div>
+    <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">Pool d'IDs placeholder messages (un par ligne)</label>
-            <textarea class="form-control" name="messagePlaceholderIds" rows="5"></textarea>
-          </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. IMPORTANT : ne réutilise pas les mêmes IDs dans les deux pools.</p>
+    </div>
 
-          <button type="button" class="btn btn-primary ezoic-infinite-save">
-            <i class="fa fa-save"></i> Enregistrer
-          </button>
-        </form>
-      </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>
-  </div>
 
-  <div class="col-lg-3">
-    <div class="card">
-      <div class="card-header">
-        <strong>Aide</strong>
-      </div>
-      <div class="card-body">
-        <p>Placeholder Ezoic :</p>
-        <pre class="mb-0">&lt;div id="ezoic-pub-ad-placeholder-123"&gt;&lt;/div&gt;</pre>
-        <hr />
-        <p class="mb-0">Les IDs doivent exister côté Ezoic (ad units configurées).</p>
-      </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>
-  </div>
+
+    <button id="save" class="btn btn-primary">Enregistrer</button>
+  </form>
 </div>