nodebb-plugin-ezoic-infinite 1.0.2 → 1.0.5

package/README.md

@@ -0,0 +1,5 @@
+nodebb-plugin-ezoic-infinite v1.0.5
+
+- ACP kept in the same spirit as v0.9.5 (server-rendered groups + admin.settings.get/set)
+- Injection logic matches v0.9.7: showAds called one placeholder at a time, separate pools, FIFO recycling.
+- Frontend settings are read from window.config.ezoicInfinite (filter:config.get), no admin endpoints used on frontend.

package/library.js

@@ -1,4 +1,3 @@
-
 'use strict';
 
 const meta = require.main.require('./src/meta');
@@ -6,7 +5,7 @@ const groups = require.main.require('./src/groups');
 
 const Plugin = {};
 
-Plugin.init = async ({ router, middleware }) => {
+Plugin.init = async function ({ router, middleware }) {
   router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
   router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
 };
@@ -15,24 +14,33 @@ async function renderAdmin(req, res) {
   const settings = await meta.settings.get('ezoic-infinite');
 
   let groupNames = [];
-  try {
-    groupNames = await groups.getGroupsFromSet('groups:createtime', 0, -1);
-  } catch (e) {}
+  const candidates = ['groups:createtime', 'groups:visible:createtime', 'groups:alphabetical', 'groups:visible:alphabetical'];
+  for (const set of candidates) {
+    try {
+      groupNames = await groups.getGroupsFromSet(set, 0, -1);
+      if (Array.isArray(groupNames) && groupNames.length) break;
+    } catch (e) {}
+  }
 
   let groupList = [];
   try {
     groupList = await groups.getGroupsData(groupNames);
   } catch (e) {
-    groupList = groupNames.map(name => ({ name }));
+    groupList = (groupNames || []).map((name) => ({ name }));
   }
 
+  groupList = (groupList || [])
+    .filter(g => g && g.name)
+    .sort((a, b) => (a.name || '').localeCompare(b.name || '', 'fr', { sensitivity: 'base' }));
+
   res.render('admin/plugins/ezoic-infinite', {
+    title: 'Ezoic - Publicités Infinite Scroll',
     settings,
     groups: groupList,
   });
 }
 
-Plugin.addAdminNavigation = async (header) => {
+Plugin.addAdminNavigation = async function (header) {
   header.plugins = header.plugins || [];
   header.plugins.push({
     route: '/plugins/ezoic-infinite',
@@ -42,8 +50,9 @@ Plugin.addAdminNavigation = async (header) => {
   return header;
 };
 
-Plugin.addConfig = async (config) => {
-  config.ezoicInfinite = await meta.settings.get('ezoic-infinite');
+Plugin.addConfig = async function (config) {
+  const settings = await meta.settings.get('ezoic-infinite');
+  config.ezoicInfinite = settings || {};
   return config;
 };
 

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.0.2",
-  "description": "Ezoic Infinite (rollback to 0.8.2 behaviour)",
+  "version": "1.0.5",
+  "description": "Ezoic ads injection for NodeBB 4.x (ACP stable like 0.9.5 + injection logic like 0.9.7).",
   "main": "library.js",
   "license": "MIT",
+  "keywords": [
+    "nodebb",
+    "nodebb-plugin",
+    "ezoic",
+    "ads",
+    "infinite-scroll"
+  ],
   "nbbpm": {
     "compatibility": "^4.0.0"
   }

package/plugin.json

@@ -1,6 +1,7 @@
 {
   "id": "nodebb-plugin-ezoic-infinite",
   "name": "Ezoic Infinite",
+  "description": "Ezoic ads injection (topics list + topic posts) with pool recycling for infinite scroll.",
   "library": "./library.js",
   "hooks": [
     {
@@ -25,5 +26,8 @@
   "scripts": [
     "public/client.js"
   ],
+  "css": [
+    "public/style.css"
+  ],
   "templates": "public/templates"
 }

package/public/admin.js

@@ -1,35 +1,59 @@
+/* global $, app, socket */
+'use strict';
 
-/* global $, socket, app */
-$(function () {
-  const ns = 'ezoic-infinite';
-  const form = $('.ezoic-infinite-settings');
-
-  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)
-      );
+(function () {
+  if (window.ezoicInfiniteAdminLoaded) return;
+  window.ezoicInfiniteAdminLoaded = true;
+
+  $(document).ready(function () {
+    const namespace = 'ezoic-infinite';
+
+    function load() {
+      socket.emit('admin.settings.get', { hash: namespace }, function (err, data) {
+        if (err) return;
+        data = data || {};
+
+        const form = $('.ezoic-infinite-settings');
+
+        form.find('[name="enableBetweenAds"]').prop('checked', data.enableBetweenAds === true || data.enableBetweenAds === 'on');
+        form.find('[name="intervalTopics"]').val(parseInt(data.intervalTopics, 10) || 6);
+        form.find('[name="placeholderIds"]').val(data.placeholderIds || '');
+
+        form.find('[name="enableMessageAds"]').prop('checked', data.enableMessageAds === true || data.enableMessageAds === 'on');
+        form.find('[name="messageIntervalPosts"]').val(parseInt(data.messageIntervalPosts, 10) || 3);
+        form.find('[name="messagePlaceholderIds"]').val(data.messagePlaceholderIds || '');
+
+        const selected = (data.excludedGroups || '').split(',').map(s => s.trim()).filter(Boolean);
+        form.find('[name="excludedGroups"] option').each(function () {
+          $(this).prop('selected', selected.includes($(this).val()));
+        });
+      });
+    }
+
+    function save() {
+      const form = $('.ezoic-infinite-settings');
+      const payload = {
+        enableBetweenAds: form.find('[name="enableBetweenAds"]').is(':checked'),
+        intervalTopics: parseInt(form.find('[name="intervalTopics"]').val(), 10) || 6,
+        placeholderIds: form.find('[name="placeholderIds"]').val() || '',
+
+        enableMessageAds: form.find('[name="enableMessageAds"]').is(':checked'),
+        messageIntervalPosts: parseInt(form.find('[name="messageIntervalPosts"]').val(), 10) || 3,
+        messagePlaceholderIds: form.find('[name="messagePlaceholderIds"]').val() || '',
+
+        excludedGroups: (form.find('[name="excludedGroups"]').val() || []).join(','),
+      };
+
+      socket.emit('admin.settings.set', { hash: namespace, values: payload }, function (err) {
+        if (err) {
+          app.alertError(err.message || err);
+          return;
+        }
+        app.alertSuccess('Paramètres enregistrés');
+      });
     }
-  });
 
-  $('.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(',');
-
-    socket.emit('admin.settings.set', { hash: ns, values }, err => {
-      if (err) app.alertError(err.message);
-      else app.alertSuccess('Enregistré');
-    });
+    $(document).on('click', '.ezoic-infinite-save', save);
+    load();
   });
-});
+})();

package/public/client.js

@@ -1,6 +1,271 @@
+/* global $, ajaxify, app */
+'use strict';
 
-/* global config */
 (function () {
-  if (!config || !config.ezoicInfinite) return;
-  // Same logic as stable 0.8.x
+  if (window.ezoicInfiniteLoaded) return;
+  window.ezoicInfiniteLoaded = true;
+
+  function getSettings() {
+    return (window.config && window.config.ezoicInfinite) ? window.config.ezoicInfinite : {};
+  }
+
+  let settings = getSettings();
+  let pageKey = null;
+
+  let usedBetween = new Set();
+  let usedMessage = new Set();
+  let fifoBetween = [];
+  let fifoMessage = [];
+
+  let refreshInFlight = false;
+  let refreshQueued = false;
+
+  function parsePool(text) {
+    return String(text || '')
+      .split(/\r?\n/)
+      .map(s => s.trim())
+      .filter(Boolean)
+      .map(s => parseInt(s, 10))
+      .filter(n => Number.isFinite(n) && n > 0);
+  }
+
+  function userExcluded() {
+    try {
+      const raw = (settings && settings.excludedGroups) ? String(settings.excludedGroups) : '';
+      if (!raw) return false;
+      const excluded = raw.split(',').map(s => s.trim()).filter(Boolean);
+      if (!excluded.length) return false;
+      const myGroups = (app.user && app.user.groups) ? app.user.groups : [];
+      return excluded.some(g => myGroups.includes(g));
+    } catch (e) { return false; }
+  }
+
+  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 $('li[component="category/topic"]').length > 0 && !isTopicPage();
+  }
+
+  function cleanupForNewPage() {
+    $('.ezoic-ad').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) {
+      try { $(wrap).remove(); } catch (e) { wrap.remove(); }
+    } else {
+      existing.remove();
+    }
+    destroyPlaceholder(id);
+  }
+
+  function callEzoicSingle(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;
+
+    try {
+      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;
+      const tick = function () {
+        tries++;
+        if (run() || tries >= 8) return;
+        setTimeout(tick, 800);
+      };
+      setTimeout(tick, 800);
+    } catch (e) {}
+  }
+
+  function pickNextId(pool, usedSet) {
+    for (const id of pool) if (!usedSet.has(id)) return id;
+    return null;
+  }
+
+  function recycle(fifo, usedSet, selectorFn) {
+    fifo.sort((a, b) => a.after - b.after);
+    while (fifo.length) {
+      const old = fifo.shift();
+      const $el = selectorFn(old);
+      if (!$el.length) continue;
+
+      $el.remove();
+      usedSet.delete(old.id);
+      destroyPlaceholder(old.id);
+      return old.id;
+    }
+    return null;
+  }
+
+  function insertAfter($target, id, cls, afterVal) {
+    ensureUniquePlaceholder(id);
+    const wrap = $(
+      '<div class="ezoic-ad ' + cls + '" data-ezoic-id="' + id + '" data-ezoic-after="' + afterVal + '">' +
+        '<div class="ezoic-ad-inner"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>' +
+      '</div>'
+    );
+    $target.after(wrap);
+  }
+
+  function injectBetweenTopics() {
+    if (!(settings && (settings.enableBetweenAds === true || settings.enableBetweenAds === 'on'))) return;
+
+    const interval = parseInt(settings.intervalTopics, 10) || 6;
+    const pool = parsePool(settings.placeholderIds);
+    if (!pool.length) return;
+
+    const $items = $('li[component="category/topic"]');
+    if (!$items.length) return;
+
+    $items.each(function (idx) {
+      const pos = idx + 1;
+      if (pos % interval !== 0) return;
+      if (idx === $items.length - 1) return;
+
+      const $li = $(this);
+      if ($li.next('.ezoic-ad-between').length) 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;
+      }
+
+      usedBetween.add(id);
+      fifoBetween.push({ id, after: pos });
+
+      insertAfter($li, id, 'ezoic-ad-between', pos);
+      callEzoicSingle(id);
+    });
+  }
+
+  function injectBetweenMessages() {
+    if (!(settings && (settings.enableMessageAds === true || settings.enableMessageAds === 'on'))) return;
+
+    const interval = parseInt(settings.messageIntervalPosts, 10) || 3;
+    const pool = parsePool(settings.messagePlaceholderIds);
+    if (!pool.length) return;
+
+    const $posts = $('[component="post"][data-pid]');
+    if (!$posts.length) return;
+
+    $posts.each(function (idx) {
+      const postNo = idx + 1;
+      if (postNo % interval !== 0) return;
+      if (idx === $posts.length - 1) return;
+
+      const $post = $(this);
+      if ($post.next('.ezoic-ad-message').length) 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: postNo });
+
+      insertAfter($post, id, 'ezoic-ad-message', postNo);
+      callEzoicSingle(id);
+    });
+  }
+
+  function refresh() {
+    settings = getSettings();
+    if (!settings) return;
+    if (userExcluded()) return;
+
+    if (refreshInFlight) { refreshQueued = true; return; }
+    refreshInFlight = true;
+
+    try {
+      const key = getPageKey();
+      if (pageKey !== key) {
+        pageKey = key;
+        cleanupForNewPage();
+      }
+
+      if (isTopicPage()) injectBetweenMessages();
+      else if (isCategoryTopicList()) injectBetweenTopics();
+    } finally {
+      refreshInFlight = false;
+      if (refreshQueued) { refreshQueued = false; setTimeout(refresh, 50); }
+    }
+  }
+
+  function boot() {
+    refresh();
+    setTimeout(refresh, 1200);
+  }
+
+  $(document).ready(boot);
+  $(window).on('action:ajaxify.end', boot);
+
+  $(window).on('action:posts.loaded action:topics.loaded action:topic.loaded action:category.loaded', function () {
+    refresh();
+    setTimeout(refresh, 600);
+  });
+
+  $(window).on('action:ajaxify.start', function () {
+    pageKey = null;
+    cleanupForNewPage();
+  });
 })();

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,23 +1,78 @@
+<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="10">
+              <!-- 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>
 
-<form class="ezoic-infinite-settings">
-  <label>Groupes exclus</label>
-  <select name="excludedGroups" multiple>
-    <!-- BEGIN groups -->
-    <option value="{groups.name}">{groups.name}</option>
-    <!-- END groups -->
-  </select>
+          <hr />
 
-  <hr>
+          <h5>Publicités entre les topics (liste des sujets)</h5>
 
-  <label><input type="checkbox" name="enableBetweenAds"> Activer pubs entre topics</label>
-  <input type="number" name="intervalTopics" value="6">
-  <textarea name="placeholderIds"></textarea>
+          <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>
 
-  <hr>
+          <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>
 
-  <label><input type="checkbox" name="enableMessageAds"> Activer pubs entre messages</label>
-  <input type="number" name="messageIntervalPosts" value="3">
-  <textarea name="messagePlaceholderIds"></textarea>
+          <div class="mb-3">
+            <label class="form-label">Pool d'IDs placeholder (un par ligne)</label>
+            <textarea class="form-control" name="placeholderIds" rows="6"></textarea>
+          </div>
 
-  <button type="button" class="ezoic-save">Enregistrer</button>
-</form>
+          <hr />
+
+          <h5>Publicités entre les messages (dans un topic)</h5>
+
+          <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>
+
+          <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="mb-3">
+            <label class="form-label">Pool d'IDs placeholder messages (un par ligne)</label>
+            <textarea class="form-control" name="messagePlaceholderIds" rows="6"></textarea>
+          </div>
+
+          <button type="button" class="btn btn-primary ezoic-infinite-save">
+            <i class="fa fa-save"></i> Enregistrer
+          </button>
+        </form>
+      </div>
+    </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>
+    </div>
+  </div>
+</div>