hye understand what i am trying to build here and i want to add endpint named analytics that serves various data based on the logs that have been stored and make it good and proper and iverse data it should be everything data nalytic and very depth into every aspect like filteration and everything i am trying to buidl a very indepth dashboard make it good give me best and complete endpoint covering every analytic need and filter for everythign and cover every edge case 
"""
// models/Log.js

const mongoose = require('mongoose');

const logSchema = new mongoose.Schema({
    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    url: { type: String, required: true },
    statusCode: { type: Number, required: true },
    checkedAt: { type: Date, default: Date.now },
    screenshotUrl: { type: String, default: '' }, // Relative path to the screenshot
}, { timestamps: true });

module.exports = mongoose.model('Log', logSchema);
"""
""
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    username: { type: String, unique: true, sparse: true, minlength: 3, maxlength: 30 },
    email: { type: String, unique: true, sparse: true, maxlength: 100 },
    password: { type: String, required: true, minlength: 6 },
    listOfUrls: { type: [String], default: [] },
    timePeriod: { 
        type: String, 
        enum: ['30s', '1m', '3m', '5m', '10m', '1h'], 
        default: '1m' 
    },
    emailSend: { type: Boolean, default: false },
    verificationToken: { type: String },
    verified: { type: Boolean, default: false },
}, { timestamps: true });

// Adding indexes for sparse unique fields
userSchema.index({ username: 1 }, { unique: true, sparse: true });
userSchema.index({ email: 1 }, { unique: true, sparse: true });

module.exports = mongoose.model('User', userSchema);
"""
"""
// routes/authRoutes.js

const express = require('express');
const router = express.Router();
const authController = require('../controllers/authController');

// Existing routes
router.post('/signup', authController.signup);
router.post('/login', authController.login);

// New verification routes
router.post('/verify-email', authController.verifyEmail);
router.post('/resend-verification', authController.resendVerificationEmail);
router.get('/check-verification/:userId', authController.checkVerificationStatus);

module.exports = router;
"""
"""
// routes/userRoutes.js

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
const authenticate = require('../middlewares/authenticate');
const ensureVerified = require('../middlewares/ensureVerified'); // We'll create this middleware

// Apply both authentication and verification checks
router.put('/settings', authenticate, ensureVerified, userController.updateSettings);
router.get('/logs', authenticate, ensureVerified, userController.getUserLogs);

// **New Routes for Monitoring Control**
router.post('/monitor/start', authenticate, ensureVerified, userController.startMonitoring);
router.post('/monitor/stop', authenticate, ensureVerified, userController.stopMonitoring);

module.exports = router;
"""
"""
// services/emailService.js

const nodemailer = require('nodemailer');
const logger = require('../utils/logger');
const path = require('path');

// Create transporter
const transporter = nodemailer.createTransport({
    service: "Gmail",
    auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS,
    },
});
  

const sendErrorNotification = async (to, url, statusCode, screenshotUrl) => {
    const subject = `🚨 Issue Detected on ${url}`;
    let htmlContent = `
        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #e0e0e0; border-radius: 8px; background-color: #f9f9f9;">
            <h2 style="color: #e63946;">⚠️ Issue Detected on Your Website</h2>
            <p style="color: #333;">Dear User,</p>
            <p>We encountered an issue when accessing your site:</p>
            <p style="font-size: 16px;"><strong>URL:</strong> <a href="${url}" style="color: #007bff; text-decoration: none;">${url}</a></p>
            <p style="font-size: 16px;"><strong>Status Code:</strong> <span style="color: #dc3545;">${statusCode}</span></p>
            
            ${screenshotUrl ? `
                <p style="font-size: 16px;"><strong>Screenshot:</strong> 
                <a href="${screenshotUrl}" style="color: #007bff; text-decoration: none;">View Screenshot</a></p>
                <div style="text-align: center; margin-top: 10px;">
                    <img src="${screenshotUrl}" alt="Screenshot" style="max-width: 100%; border: 1px solid #ddd; border-radius: 4px;">
                </div>
            ` : ''}

            <p style="margin-top: 20px; font-size: 14px; color: #666;">Please check and resolve the issue as soon as possible to ensure uninterrupted service.</p>
            <p style="font-size: 14px; color: #666;">Best regards,</p>
            <p style="font-size: 14px; color: #333; font-weight: bold;">Your Monitoring Team</p>
        </div>
    `;

    const mailOptions = {
        from: process.env.EMAIL_USER,
        to,
        subject,
        html: htmlContent,
    };

    try {
        await transporter.sendMail(mailOptions);
        logger.info(`Sent error notification email to ${to} for ${url}`);
    } catch (error) {
        logger.error(`Failed to send email notification to ${to} for ${url}: ${error.message}`);
    }
};

const sendVerificationEmail = async (email, token) => {
    const verificationLink = `${process.env.FRONTEND_URL}/verify-email?token=${token}`;
    const subject = '🌟 Verify Your Email - Welcome to Our Service!';
    
    const htmlContent = `
        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #e0e0e0; border-radius: 8px; background-color: #f9f9f9;">
            <h2 style="color: #28a745;">Welcome to Our Service! 🎉</h2>
            <p style="color: #333;">Hello,</p>
            <p>Thank you for signing up! Please confirm your email address to activate your account.</p>
            <div style="text-align: center; margin: 20px 0;">
                <a href="${verificationLink}" style="text-decoration: none;">
                    <button style="padding: 12px 24px; background-color: #28a745; color: #ffffff; font-size: 16px; font-weight: bold; border: none; border-radius: 5px; cursor: pointer;">
                        Verify Email
                    </button>
                </a>
            </div>
            <p style="font-size: 14px; color: #666;">If you did not sign up for this account, you can safely ignore this email.</p>
            <p style="font-size: 14px; color: #666;">Welcome aboard, and we’re excited to have you with us!</p>
            <p style="font-size: 14px; color: #333; font-weight: bold;">Best regards,</p>
            <p style="font-size: 14px; color: #333;">Your Support Team</p>
        </div>
    `;

    const mailOptions = {
        from: process.env.EMAIL_USER,
        to: email,
        subject,
        html: htmlContent,
    };

    try {
        await transporter.sendMail(mailOptions);
        logger.info(`Verification email sent to ${email}`);
    } catch (error) {
        logger.error(`Error sending verification email to ${email}: ${error.message}`);
        throw new Error('Unable to send verification email');
    }
};



module.exports = {
    sendErrorNotification,
    sendVerificationEmail,
};
"""
"""
// services/monitorService.js

const axios = require('axios');
const cron = require('node-cron');
const Log = require('../models/Log');
const screenshotService = require('./screenshotService');
const emailService = require('./emailService');
const logger = require('../utils/logger');

// Helper: Convert time period to cron expression
const timePeriodToCron = (timePeriod) => {
    switch (timePeriod) {
        case '1m':
            return '*/1 * * * *';
        case '3m':
            return '*/3 * * * *';
        case '5m':
            return '*/5 * * * *';
        case '10m':
            return '*/10 * * * *';
        case '1h':
            return '0 * * * *';
        default:
            return '*/1 * * * *'; // Default to every minute
    }
};

// In-memory storage for cron jobs and intervals
const userJobs = new Map();
const userIntervals = new Map();

// In-memory storage for notification timers
// Structure: { userId: { url: timeoutObject } }
const notificationTimers = new Map();

/**
 * Function to perform checks on user's URLs.
 * Logs all status codes, handles notifications for non-2xx responses,
 * and captures screenshots for error notifications.
 *
 * @param {Object} user - The user object containing monitoring details.
 */
const performChecks = async (user) => {
    for (const url of user.listOfUrls) {
        try {
            const response = await axios.get(url, { timeout: 10000 });
            const statusCode = response.status;

            // Log successful check with no screenshot
            await logStatus(user._id, url, statusCode, "None");

            if (statusCode < 200 || statusCode >= 300) {
                logger.warn(`URL check failed for ${url} with status code ${statusCode}`);

                if (isNotificationPending(user._id.toString(), url)) {
                    logger.info(`Notification already pending for ${url}. Skipping email.`);
                    continue;
                }

                const screenshotUrl = await screenshotService.takeScreenshot(url);
                await emailService.sendErrorNotification(user.email, url, statusCode, screenshotUrl);
                await logStatus(user._id, url, statusCode, screenshotUrl); // Log with screenshot URL

                setNotificationTimer(user._id.toString(), url, 10 * 60 * 1000); // 10 minutes
            } else {
                logger.info(`URL check successful for ${url} with status code ${statusCode}`);
                clearNotificationTimer(user._id.toString(), url);
            }
        } catch (error) {
            let statusCode = error.response ? error.response.status : 0;
            let screenshotUrl = 'None';

            if (statusCode !== 0) {
                try {
                    screenshotUrl = await screenshotService.takeScreenshot(url);
                    logger.info(`Screenshot captured for ${url}`);
                } catch (screenshotError) {
                    logger.error(`Failed to take screenshot for ${url}: ${screenshotError.message}`);
                }
            }

            await logStatus(user._id, url, statusCode, screenshotUrl); // Log with or without screenshot
            if (!isNotificationPending(user._id.toString(), url)) {
                await emailService.sendErrorNotification(user.email, url, statusCode, screenshotUrl);
                setNotificationTimer(user._id.toString(), url, 10 * 60 * 1000);
            }
        }
    }
};

/**
 * Logs the status of the URL check to the database.
 *
 * @param {ObjectId} userId - The ID of the user.
 * @param {string} url - The URL that was checked.
 * @param {number} statusCode - The HTTP status code returned.
 */
const logStatus = async (userId, url, statusCode, screenshotUrl) => {
    try {
        const log = new Log({
            user: userId,
            url,
            statusCode,
            screenshotUrl,
            timestamp: new Date(),
        });
        await log.save();
        logger.info(`Logged status for ${url} with status code ${statusCode} and screenshot URL: ${screenshotUrl}`);
    } catch (logError) {
        logger.error(`Failed to log status for ${url}: ${logError.message}`);
    }
};

// Function to start monitoring for a user
const startMonitoring = (user) => {
    if (!user.verified) {
        logger.warn(`Attempted to start monitoring for unverified user: ${user.username}`);
        throw new Error('Email not verified. Please verify your email before starting monitoring.');
    }

    if (!user.listOfUrls || user.listOfUrls.length === 0) return;

    // Clear existing jobs or intervals to prevent duplicates
    stopMonitoring(user);

    if (user.timePeriod === '30s') {
        // node-cron doesn't support seconds intervals, use setInterval
        const interval = setInterval(() => {
            performChecks(user);
        }, 30000); // 30 seconds

        userIntervals.set(user._id.toString(), interval);
        logger.info(`Started 30s interval monitoring for user ${user.username}`);
    } else {
        const cronExpression = timePeriodToCron(user.timePeriod);
        if (!cronExpression) return;

        const job = cron.schedule(cronExpression, () => {
            performChecks(user);
        }, {
            scheduled: true,
            timezone: "UTC",
        });

        userJobs.set(user._id.toString(), job);
        logger.info(`Started cron job (${cronExpression}) monitoring for user ${user.username}`);
    }
};

// Function to stop monitoring for a user
const stopMonitoring = (user) => {
    const userId = user._id.toString();

    if (userJobs.has(userId)) {
        const job = userJobs.get(userId);
        job.stop();
        userJobs.delete(userId);
        logger.info(`Stopped cron job monitoring for user ${user.username}`);
    }

    if (userIntervals.has(userId)) {
        clearInterval(userIntervals.get(userId));
        userIntervals.delete(userId);
        logger.info(`Stopped interval monitoring for user ${user.username}`);
    }

    // Also clear any pending notification timers
    if (notificationTimers.has(userId)) {
        Object.values(notificationTimers.get(userId)).forEach(timeout => clearTimeout(timeout));
        notificationTimers.delete(userId);
        logger.info(`Cleared notification timers for user ${user.username}`);
    }
};

// Function to restart monitoring (used when settings are updated)
const restartMonitoring = (user) => {
    if (!user.verified) {
        logger.warn(`Attempted to restart monitoring for unverified user: ${user.username}`);
        throw new Error('Email not verified. Please verify your email before restarting monitoring.');
    }
    startMonitoring(user);
};

// Function to check if monitoring is active for a user
const isMonitoringActive = (userId) => {
    return userJobs.has(userId) || userIntervals.has(userId);
};

// Function to check if a notification is pending for a URL
const isNotificationPending = (userId, url) => {
    if (!notificationTimers.has(userId)) return false;
    const userTimers = notificationTimers.get(userId);
    return userTimers.hasOwnProperty(url);
};

// Function to set a notification timer for a URL
const setNotificationTimer = (userId, url, timeout) => {
    if (!notificationTimers.has(userId)) {
        notificationTimers.set(userId, {});
    }
    const userTimers = notificationTimers.get(userId);
    userTimers[url] = setTimeout(() => {
        // Timer expired, remove the pending notification
        if (notificationTimers.has(userId)) {
            delete notificationTimers.get(userId)[url];
            logger.info(`Notification timer expired for ${url}`);
            // Optionally, notify the user that monitoring is active again
            // Example:
            // emailService.sendRecoveryNotification(user.email, url);
        }
    }, timeout);
};

// Function to clear notification timer (called when URL recovers)
const clearNotificationTimer = (userId, url) => {
    if (!notificationTimers.has(userId)) return;
    const userTimers = notificationTimers.get(userId);
    if (userTimers.hasOwnProperty(url)) {
        clearTimeout(userTimers[url]);
        delete userTimers[url];
        logger.info(`Cleared notification timer for ${url}`);
    }
};

// Initialize monitoring for existing users on server start
const initializeMonitoring = async () => {
    const User = require('../models/User'); // Avoid circular dependency
    try {
        const users = await User.find({ verified: true }); // Only initialize for verified users
        users.forEach(user => {
            startMonitoring(user);
        });
        logger.info('Initialized monitoring for existing verified users');
    } catch (error) {
        logger.error('Error initializing monitoring:', error);
    }
};

module.exports = {
    startMonitoring,
    stopMonitoring,
    restartMonitoring,
    initializeMonitoring,
    isMonitoringActive,
};
""""
"""
// services/screenshotService.js

const puppeteer = require('puppeteer');
const cloudinary = require('../config/cloudinary');
const sharp = require('sharp');
const logger = require('../utils/logger');
const streamifier = require('streamifier');

// Initialize Puppeteer browser instance
let browserInstance = null;

const initBrowser = async () => {
  if (!browserInstance) {
    browserInstance = await puppeteer.launch({ args: ['--no-sandbox'] });
    logger.info('Puppeteer browser launched');
  }
  return browserInstance;
};

// Function to take a screenshot, compress, upload to Cloudinary, and return the URL
const takeScreenshot = async (url) => {
  try {
    const browser = await initBrowser();
    const page = await browser.newPage();

    // Set a reasonable viewport size
    await page.setViewport({ width: 1280, height: 800 });

    // Navigate to the URL
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 }); // 30 seconds timeout

    // Capture the screenshot as a buffer
    const screenshotBuffer = await page.screenshot({ fullPage: true });

    await page.close();

    logger.info(`Screenshot captured for ${url}`);

    // Compress the image using Sharp
    const compressedBuffer = await sharp(screenshotBuffer)
      .jpeg({ quality: 20 }) // Adjust quality as needed (30 for high compression)
      .toBuffer();

    logger.info(`Screenshot compressed for ${url}`);

    // Generate a unique filename
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const sanitizedUrl = url.replace(/[^a-zA-Z0-9]/g, '_');
    const filename = `${sanitizedUrl}_${timestamp}`; // Removed extension

    // Upload the compressed image to Cloudinary using a single upload_stream
    const uploadPromise = new Promise((resolve, reject) => {
      const stream = cloudinary.uploader.upload_stream(
        {
          folder: 'screenshots', // Optional: specify a folder in Cloudinary
          public_id: filename,
          resource_type: 'image',
          format: 'jpg', // Specify the format to ensure consistent extension
        },
        (error, result) => {
          if (error) {
            logger.error(`Cloudinary upload error for ${url}: ${error.message}`);
            return reject(error);
          } else {
            logger.info(`Screenshot uploaded to Cloudinary: ${result.secure_url}`);
            return resolve(result.secure_url);
          }
        }
      );
      streamifier.createReadStream(compressedBuffer).pipe(stream);
    });

    const cloudinaryUrl = await uploadPromise;

    return cloudinaryUrl; // Return the Cloudinary URL
  } catch (error) {
    logger.error(`Error taking screenshot for ${url}: ${error.message}`);
    throw error;
  }
};

module.exports = {
  takeScreenshot,
};
"""
"""
// utils/logger.js

const { createLogger, format, transports } = require('winston');
const path = require('path');

// Define log format
const logFormat = format.printf(({ level, message, timestamp }) => {
    return `${timestamp} [${level.toUpperCase()}]: ${message}`;
});

// Create logger instance
const logger = createLogger({
    level: 'info',
    format: format.combine(
        format.timestamp(),
        logFormat
    ),
    transports: [
        // Console output
        new transports.Console(),
        // File outputs
        new transports.File({ filename: path.join(__dirname, '../logs/error.log'), level: 'error' }),
        new transports.File({ filename: path.join(__dirname, '../logs/combined.log') }),
    ],
    exitOnError: false,
});

module.exports = logger;
"""
"""
// server.js

const express = require('express');
const dotenv = require('dotenv');
const helmet = require('helmet');
const cors = require('cors');
const rateLimit = require('express-rate-limit');
const path = require('path');
const connectDB = require('./config/db');
const errorHandler = require('./middlewares/errorHandler');
const authRoutes = require('./routes/authRoutes');
const userRoutes = require('./routes/userRoutes');
const monitorService = require('./services/monitorService');
const logger = require('./utils/logger');

// Load environment variables
dotenv.config();

// Initialize Express
const app = express();

// Connect to MongoDB
connectDB();

// Middleware
app.use(express.json());
app.use(helmet());
app.use(cors({
    origin: ['http://localhost:3000'], // Replace with your frontend domain
    methods: ['GET', 'POST', 'PUT', 'DELETE'],
    credentials: true,
}));

// Rate Limiting
const authLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP, please try again after 15 minutes',
});

app.use('/api/auth/signup', authLimiter);
app.use('/api/auth/login', authLimiter);
app.use('/api/user/settings', authLimiter);
app.use('/api/user/logs', authLimiter);

// Routes
app.use('/api/auth', authRoutes);
app.use('/api/user', userRoutes);

// Global Error Handler
app.use(errorHandler);

// Start Monitoring for Existing Users
monitorService.initializeMonitoring();

// Start Server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    logger.info(`Server is running on port ${PORT}`);
});
"""
// middlewares/authenticate.js

const jwt = require('jsonwebtoken');
const logger = require('../utils/logger');

const authenticateToken = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];
    if (!token) return res.status(401).json({ message: 'Access Token Required' });

    jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
        if (err) {
            logger.warn('Invalid Token:', err);
            return res.status(403).json({ message: 'Invalid Token' });
        }
        req.user = user;
        next();
    });
};

module.exports = authenticateToken;
"""
"""

const User = require('../models/User');

const ensureVerified = async (req, res, next) => {
    try {
        const user = await User.findById(req.user.id).select('verified');
        if (!user) {
            return res.status(404).json({ message: 'User not found' });
        }
        if (!user.verified) {
            return res.status(403).json({ message: 'Email not verified. Please verify your email to perform this action.' });
        }
        next();
    } catch (error) {
        res.status(500).json({ message: 'Internal server error' });
    }
};

module.exports = ensureVerified;
"""
"""
// middlewares/errorHandler.js

const logger = require('../utils/logger');

const errorHandler = (err, req, res, next) => {
    logger.error('Unhandled Error:', err.stack);
    res.status(500).json({ message: 'Something went wrong!' });
};

module.exports = errorHandler;
"""