@intranefr/superbackend 1.4.3

package/src/controllers/metrics.controller.js

@@ -0,0 +1,149 @@
+const crypto = require('crypto');
+const ActionEvent = require('../models/ActionEvent');
+const GlobalSetting = require('../models/GlobalSetting');
+const { verifyAccessToken } = require('../utils/jwt');
+const User = require('../models/User');
+
+function parseCookieHeader(cookieHeader) {
+  const out = {};
+  if (!cookieHeader) return out;
+  const parts = cookieHeader.split(';');
+  for (const p of parts) {
+    const idx = p.indexOf('=');
+    if (idx === -1) continue;
+    const k = p.slice(0, idx).trim();
+    const v = p.slice(idx + 1).trim();
+    if (!k) continue;
+    out[k] = decodeURIComponent(v);
+  }
+  return out;
+}
+
+function getMonthRange(date = new Date()) {
+  const start = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1, 0, 0, 0, 0));
+  const end = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1, 0, 0, 0, 0));
+  return { start, end };
+}
+
+function getAnonId(req) {
+  const headerAnon = req.get('x-anon-id');
+  if (headerAnon) return String(headerAnon).trim();
+
+  const cookies = parseCookieHeader(req.headers.cookie);
+  if (cookies.enbauges_anon_id) return String(cookies.enbauges_anon_id).trim();
+
+  const bodyAnon = req.body?.anonId;
+  if (bodyAnon) return String(bodyAnon).trim();
+
+  return null;
+}
+
+async function tryAttachUser(req) {
+  if (req.user?._id) return;
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) return;
+
+  try {
+    const token = authHeader.substring(7);
+    const decoded = verifyAccessToken(token);
+    const user = await User.findById(decoded.userId);
+    if (user) req.user = user;
+  } catch (e) {
+    // optional auth: ignore errors
+  }
+}
+
+exports.track = async (req, res) => {
+  try {
+    await tryAttachUser(req);
+
+    const action = String(req.body?.action || '').trim();
+    const meta = req.body?.meta ?? null;
+
+    if (!action) {
+      return res.status(400).json({ error: 'action is required' });
+    }
+
+    let actorType = 'anonymous';
+    let actorId = getAnonId(req);
+
+    if (req.user?._id) {
+      actorType = 'user';
+      actorId = String(req.user._id);
+    }
+
+    if (!actorId) {
+      actorId = crypto.randomUUID();
+      res.cookie('enbauges_anon_id', actorId, {
+        httpOnly: false,
+        sameSite: 'lax',
+        maxAge: 1000 * 60 * 60 * 24 * 365,
+        path: '/',
+      });
+    }
+
+    await ActionEvent.create({
+      action,
+      actorType,
+      actorId,
+      meta,
+    });
+
+    return res.json({ ok: true, actorType, anonId: actorType === 'anonymous' ? actorId : null });
+  } catch (error) {
+    console.error('Metrics track error:', error);
+    return res.status(500).json({ error: 'Failed to track' });
+  }
+};
+
+exports.getImpact = async (req, res) => {
+  try {
+    const { start, end } = getMonthRange(new Date());
+
+    const activeActorsAgg = await ActionEvent.aggregate([
+      {
+        $match: {
+          createdAt: { $gte: start, $lt: end },
+          actorType: { $in: ['user', 'anonymous'] },
+        },
+      },
+      {
+        $group: {
+          _id: {
+            actorType: '$actorType',
+            actorId: '$actorId',
+          },
+        },
+      },
+      { $count: 'count' },
+    ]);
+
+    const activeUsers = activeActorsAgg?.[0]?.count || 0;
+
+    const servicesConsulted = await ActionEvent.countDocuments({
+      action: 'service_view',
+      createdAt: { $gte: start, $lt: end },
+    });
+
+    const newsletterSetting = await GlobalSetting.findOne({ key: 'newsletter_list' }).lean();
+    let newsletterSubscribers = 0;
+    if (newsletterSetting?.value) {
+      try {
+        const parsed = JSON.parse(newsletterSetting.value);
+        if (Array.isArray(parsed)) newsletterSubscribers = parsed.length;
+      } catch (e) {
+        newsletterSubscribers = 0;
+      }
+    }
+
+    return res.json({
+      range: { start: start.toISOString(), end: end.toISOString() },
+      activeUsers,
+      servicesConsulted,
+      newsletterSubscribers,
+    });
+  } catch (error) {
+    console.error('Metrics impact error:', error);
+    return res.status(500).json({ error: 'Failed to compute impact' });
+  }
+};

package/src/controllers/notificationAdmin.controller.js

@@ -0,0 +1,264 @@
+const mongoose = require('mongoose');
+const Notification = require('../models/Notification');
+const User = require('../models/User');
+const notificationService = require('../services/notification.service');
+const { createAuditEvent, getBasicAuthActor } = require('../services/audit.service');
+
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 500;
+
+function parseLimit(value) {
+  const parsed = parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, parsed));
+}
+
+function parseOffset(value) {
+  const parsed = parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return 0;
+  return Math.max(0, parsed);
+}
+
+exports.listNotifications = async (req, res) => {
+  try {
+    const { userId, type, channel, emailStatus, broadcastId, limit, offset } = req.query;
+
+    const parsedLimit = parseLimit(limit);
+    const parsedOffset = parseOffset(offset);
+
+    const query = {};
+
+    if (userId && mongoose.Types.ObjectId.isValid(String(userId))) {
+      query.userId = new mongoose.Types.ObjectId(String(userId));
+    }
+
+    if (type) {
+      query.type = String(type);
+    }
+
+    if (channel) {
+      query.channel = String(channel);
+    }
+
+    if (emailStatus) {
+      query.emailStatus = String(emailStatus);
+    }
+
+    if (broadcastId) {
+      query.broadcastId = String(broadcastId);
+    }
+
+    const notifications = await Notification.find(query)
+      .populate('userId', 'email name')
+      .sort({ createdAt: -1 })
+      .limit(parsedLimit)
+      .skip(parsedOffset)
+      .lean();
+
+    const total = await Notification.countDocuments(query);
+
+    return res.json({
+      notifications,
+      pagination: {
+        total,
+        limit: parsedLimit,
+        offset: parsedOffset,
+      },
+    });
+  } catch (error) {
+    console.error('Admin notification list error:', error);
+    return res.status(500).json({ error: 'Failed to list notifications' });
+  }
+};
+
+exports.getNotificationStats = async (req, res) => {
+  try {
+    const stats = await notificationService.getNotificationStats();
+    return res.json(stats);
+  } catch (error) {
+    console.error('Admin notification stats error:', error);
+    return res.status(500).json({ error: 'Failed to get notification stats' });
+  }
+};
+
+exports.sendNotification = async (req, res) => {
+  try {
+    const { userIds, type, title, message, channel = 'in_app', metadata = {} } = req.body;
+
+    if (!type || !title || !message) {
+      return res.status(400).json({ error: 'type, title, and message are required' });
+    }
+
+    if (!['info', 'success', 'warning', 'error'].includes(String(type))) {
+      return res.status(400).json({ error: 'Invalid type. Must be info, success, warning, or error.' });
+    }
+
+    if (!['in_app', 'email', 'both'].includes(String(channel))) {
+      return res.status(400).json({ error: 'Invalid channel. Must be in_app, email, or both.' });
+    }
+
+    if (!Array.isArray(userIds) || userIds.length === 0) {
+      return res.status(400).json({ error: 'userIds must be a non-empty array' });
+    }
+
+    const validUserIds = userIds.filter((id) => mongoose.Types.ObjectId.isValid(String(id)));
+    if (validUserIds.length === 0) {
+      return res.status(400).json({ error: 'No valid user IDs provided' });
+    }
+
+    const actor = getBasicAuthActor(req);
+
+    const result = await notificationService.sendToUsers({
+      userIds: validUserIds,
+      type: String(type),
+      title: String(title),
+      message: String(message),
+      channel: String(channel),
+      metadata,
+      sentByAdminId: actor.actorId,
+    });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'admin.notification.send',
+      entityType: 'Notification',
+      entityId: result.broadcastId,
+      before: null,
+      after: { userCount: validUserIds.length, type, title, channel },
+      meta: { broadcastId: result.broadcastId },
+    });
+
+    return res.status(201).json({
+      message: 'Notifications sent',
+      broadcastId: result.broadcastId,
+      results: result.results,
+    });
+  } catch (error) {
+    console.error('Admin send notification error:', error);
+    return res.status(500).json({ error: 'Failed to send notifications' });
+  }
+};
+
+exports.broadcastNotification = async (req, res) => {
+  try {
+    const { type, title, message, channel = 'in_app', metadata = {} } = req.body;
+
+    if (!type || !title || !message) {
+      return res.status(400).json({ error: 'type, title, and message are required' });
+    }
+
+    if (!['info', 'success', 'warning', 'error'].includes(String(type))) {
+      return res.status(400).json({ error: 'Invalid type. Must be info, success, warning, or error.' });
+    }
+
+    if (!['in_app', 'email', 'both'].includes(String(channel))) {
+      return res.status(400).json({ error: 'Invalid channel. Must be in_app, email, or both.' });
+    }
+
+    const actor = getBasicAuthActor(req);
+
+    const result = await notificationService.broadcast({
+      type: String(type),
+      title: String(title),
+      message: String(message),
+      channel: String(channel),
+      metadata,
+      sentByAdminId: actor.actorId,
+      userFilter: { disabled: { $ne: true } },
+    });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'admin.notification.broadcast',
+      entityType: 'Notification',
+      entityId: result.broadcastId,
+      before: null,
+      after: { userCount: result.results.length, type, title, channel },
+      meta: { broadcastId: result.broadcastId },
+    });
+
+    return res.status(201).json({
+      message: 'Broadcast sent',
+      broadcastId: result.broadcastId,
+      recipientCount: result.results.length,
+      successCount: result.results.filter((r) => r.success).length,
+      failCount: result.results.filter((r) => !r.success).length,
+    });
+  } catch (error) {
+    console.error('Admin broadcast notification error:', error);
+    return res.status(500).json({ error: 'Failed to broadcast notification' });
+  }
+};
+
+exports.deleteNotification = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    if (!id || !mongoose.Types.ObjectId.isValid(String(id))) {
+      return res.status(400).json({ error: 'Invalid notification ID' });
+    }
+
+    const notification = await Notification.findById(id);
+    if (!notification) {
+      return res.status(404).json({ error: 'Notification not found' });
+    }
+
+    const before = notification.toObject();
+    const actor = getBasicAuthActor(req);
+
+    await Notification.deleteOne({ _id: id });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'admin.notification.delete',
+      entityType: 'Notification',
+      entityId: String(id),
+      before,
+      after: null,
+      meta: null,
+    });
+
+    return res.json({ message: 'Notification deleted' });
+  } catch (error) {
+    console.error('Admin notification delete error:', error);
+    return res.status(500).json({ error: 'Failed to delete notification' });
+  }
+};
+
+exports.retryEmailNotification = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    if (!id || !mongoose.Types.ObjectId.isValid(String(id))) {
+      return res.status(400).json({ error: 'Invalid notification ID' });
+    }
+
+    const notification = await Notification.findById(id).populate('userId', 'email');
+    if (!notification) {
+      return res.status(404).json({ error: 'Notification not found' });
+    }
+
+    if (notification.channel === 'in_app') {
+      return res.status(400).json({ error: 'This notification is in-app only' });
+    }
+
+    if (notification.emailStatus === 'sent') {
+      return res.status(400).json({ error: 'Email already sent' });
+    }
+
+    const userEmail = notification.userId?.email;
+    if (!userEmail) {
+      return res.status(400).json({ error: 'User email not found' });
+    }
+
+    await notificationService.sendEmailForNotification(notification, userEmail);
+
+    return res.json({
+      message: 'Email retry attempted',
+      emailStatus: notification.emailStatus,
+    });
+  } catch (error) {
+    console.error('Admin notification retry error:', error);
+    return res.status(500).json({ error: 'Failed to retry email notification' });
+  }
+};

package/src/controllers/notifications.controller.js

@@ -0,0 +1,131 @@
+const Notification = require('../models/Notification');
+const ActivityLog = require('../models/ActivityLog');
+
+exports.getNotifications = async (req, res) => {
+  try {
+    const { limit = 50, offset = 0, unreadOnly = false } = req.query;
+    
+    const query = { userId: req.user._id };
+    if (unreadOnly === 'true') {
+      query.read = false;
+    }
+    
+    const notifications = await Notification.find(query)
+      .sort({ createdAt: -1 })
+      .limit(parseInt(limit))
+      .skip(parseInt(offset))
+      .lean();
+    
+    const total = await Notification.countDocuments(query);
+    const unreadCount = await Notification.countDocuments({ 
+      userId: req.user._id, 
+      read: false 
+    });
+    
+    res.json({
+      notifications,
+      pagination: {
+        total,
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        hasMore: total > parseInt(offset) + parseInt(limit)
+      },
+      unreadCount
+    });
+  } catch (error) {
+    console.error('Error fetching notifications:', error);
+    res.status(500).json({ error: 'Failed to fetch notifications' });
+  }
+};
+
+exports.markNotificationAsRead = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    const notification = await Notification.findOneAndUpdate(
+      { _id: id, userId: req.user._id },
+      { read: true },
+      { new: true }
+    );
+    
+    if (!notification) {
+      return res.status(404).json({ error: 'Notification not found' });
+    }
+    
+    res.json({ 
+      message: 'Notification marked as read',
+      notification 
+    });
+  } catch (error) {
+    console.error('Error marking notification as read:', error);
+    res.status(500).json({ error: 'Failed to mark notification as read' });
+  }
+};
+
+exports.getActivityLog = async (req, res) => {
+  try {
+    const { limit = 50, offset = 0, category, action } = req.query;
+    
+    const query = { userId: req.user._id };
+    if (category) query.category = category;
+    if (action) query.action = action;
+    
+    const activities = await ActivityLog.find(query)
+      .sort({ createdAt: -1 })
+      .limit(parseInt(limit))
+      .skip(parseInt(offset))
+      .lean();
+    
+    const total = await ActivityLog.countDocuments(query);
+    
+    res.json({
+      activities,
+      pagination: {
+        total,
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        hasMore: total > parseInt(offset) + parseInt(limit)
+      }
+    });
+  } catch (error) {
+    console.error('Error fetching activity log:', error);
+    res.status(500).json({ error: 'Failed to fetch activity log' });
+  }
+};
+
+exports.createActivityLog = async (req, res) => {
+  try {
+    const { action, category, description, metadata } = req.body;
+    
+    if (!action || !category || !description) {
+      return res.status(400).json({ 
+        error: 'action, category, and description are required' 
+      });
+    }
+    
+    const validCategories = ['auth', 'billing', 'content', 'settings', 'admin', 'other'];
+    if (!validCategories.includes(category)) {
+      return res.status(400).json({ 
+        error: `Invalid category. Must be one of: ${validCategories.join(', ')}` 
+      });
+    }
+    
+    const activity = await ActivityLog.create({
+      userId: req.user._id,
+      action,
+      category,
+      description,
+      ipAddress: req.ip || req.connection.remoteAddress,
+      userAgent: req.get('user-agent'),
+      metadata: metadata || {}
+    });
+    
+    res.status(201).json({
+      message: 'Activity log created',
+      activity
+    });
+  } catch (error) {
+    console.error('Error creating activity log:', error);
+    res.status(500).json({ error: 'Failed to create activity log' });
+  }
+};