nodebb-plugin-ezoic-infinite 1.6.97 → 1.6.98

package/library.js

@@ -7,60 +7,124 @@ const db = require.main.require('./src/database');
 const SETTINGS_KEY = 'ezoic-infinite';
 const plugin = {};
 
-async function getSettings() {
-    return await meta.settings.get(SETTINGS_KEY);
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
 }
 
-async function isUserExcluded(uid, excludedGroups) {
-    if (!uid || uid <= 0) return false;
-    if (!excludedGroups || !excludedGroups.length) return false;
-    const userGroups = await groups.getUserGroupsNames([uid]);
-    return excludedGroups.some(g => userGroups[0].includes(g));
+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() {
-    let names = await db.getSortedSetRange('groups:createtime', 0, -1);
-    const data = await groups.getGroupsData(names);
-    return data.filter(g => g && g.name).map(g => ({ name: g.name }));
+  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);
+  // Filter out nulls (groups deleted between the sorted-set read and getGroupsData)
+  const valid = data.filter(g => g && g.name);
+  valid.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
+  return valid;
 }
+let _settingsCache = null;
+let _settingsCacheAt = 0;
+const SETTINGS_TTL = 30000; // 30s
 
-plugin.init = async ({ router, middleware }) => {
-    async function render(req, res) {
-        const settings = await getSettings();
-        const allGroups = await getAllGroups();
-        res.render('admin/plugins/ezoic-infinite', {
-            ...settings,
-            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', async (req, res) => {
-        const settings = await getSettings();
-        const excluded = await isUserExcluded(req.uid, settings.excludedGroups || []);
-        res.json({
-            excluded,
-            enableCategoryAds: settings.enableCategoryAds === 'on',
-            showFirstCategoryAd: settings.showFirstCategoryAd === 'on',
-            categoryPlaceholderIds: settings.categoryPlaceholderIds,
-            intervalCategories: parseInt(settings.intervalCategories, 10) || 5,
-            enableBetweenAds: settings.enableBetweenAds === 'on',
-            showFirstTopicAd: settings.showFirstTopicAd === 'on',
-            placeholderIds: settings.placeholderIds,
-            intervalPosts: parseInt(settings.intervalPosts, 10) || 10,
-            enableMessageAds: settings.enableMessageAds === 'on',
-            showFirstMessageAd: settings.showFirstMessageAd === 'on',
-            messagePlaceholderIds: settings.messagePlaceholderIds,
-            messageIntervalPosts: parseInt(settings.messageIntervalPosts, 10) || 10,
-        });
-    });
+async function getSettings() {
+  const now = Date.now();
+  if (_settingsCache && (now - _settingsCacheAt) < SETTINGS_TTL) return _settingsCache;
+  const s = await meta.settings.get(SETTINGS_KEY);
+  _settingsCacheAt = Date.now();
+  _settingsCache = {
+    // Between-post ads (simple blocks) in category topic list
+    enableBetweenAds: parseBool(s.enableBetweenAds, true),
+    showFirstTopicAd: parseBool(s.showFirstTopicAd, false),
+    placeholderIds: (s.placeholderIds || '').trim(),
+    intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
+
+    // Home/categories list ads (between categories on / or /categories)
+    enableCategoryAds: parseBool(s.enableCategoryAds, false),
+    showFirstCategoryAd: parseBool(s.showFirstCategoryAd, false),
+    categoryPlaceholderIds: (s.categoryPlaceholderIds || '').trim(),
+    intervalCategories: Math.max(1, parseInt(s.intervalCategories, 10) || 4),
+
+    // "Ad message" between replies (looks like a post)
+    enableMessageAds: parseBool(s.enableMessageAds, false),
+    showFirstMessageAd: parseBool(s.showFirstMessageAd, false),
+    messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
+    messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
+
+    excludedGroups: normalizeExcludedGroups(s.excludedGroups),
+  };
+  return _settingsCache;
+}
+
+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.onSettingsSet = function (data) {
+  // Invalider le cache dès que les settings de ce plugin sont sauvegardés via l'ACP
+  if (data && data.hash === SETTINGS_KEY) {
+    _settingsCache = null;
+  }
 };
 
 plugin.addAdminNavigation = async (header) => {
-    header.plugins.push({ route: '/plugins/ezoic-infinite', icon: 'fa-ad', name: 'Ezoic Infinite' });
-    return header;
+  header.plugins = header.plugins || [];
+  header.plugins.push({
+    route: '/plugins/ezoic-infinite',
+    icon: 'fa-ad',
+    name: 'Ezoic Infinite Ads'
+  });
+  return header;
+};
+
+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', async (req, res) => {
+    const settings = await getSettings();
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
+
+    res.json({
+      excluded,
+      enableBetweenAds: settings.enableBetweenAds,
+      showFirstTopicAd: settings.showFirstTopicAd,
+      placeholderIds: settings.placeholderIds,
+      intervalPosts: settings.intervalPosts,
+      enableCategoryAds: settings.enableCategoryAds,
+      showFirstCategoryAd: settings.showFirstCategoryAd,
+      categoryPlaceholderIds: settings.categoryPlaceholderIds,
+      intervalCategories: settings.intervalCategories,
+      enableMessageAds: settings.enableMessageAds,
+      showFirstMessageAd: settings.showFirstMessageAd,
+      messagePlaceholderIds: settings.messagePlaceholderIds,
+      messageIntervalPosts: settings.messageIntervalPosts,
+    });
+  });
 };
 
-module.exports = plugin;
+module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.6.97",
+  "version": "1.6.98",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",