| const Admin = require('../models/adminModel'); |
| const User = require('../models/userModel'); |
| const ProductModel = require('../models/productModel'); |
| const asyncHandler = require('express-async-handler'); |
| const jwt = require('jsonwebtoken'); |
| const bcrypt = require('bcryptjs'); |
| const multer = require('multer'); |
| const path = require('path'); |
| const fs = require('fs'); |
| const { getNextImageNumber, isValidImageFile } = require('../utils/imageNumbering'); |
|
|
| const generateAdminToken = (res, adminId) => { |
| const token = jwt.sign({ id: adminId }, process.env.JWT_SECRET_KEY, { |
| expiresIn: '24h', |
| }); |
|
|
| const isProduction = process.env.NODE_ENV === 'production'; |
| |
| res.cookie('adminToken', token, { |
| httpOnly: true, |
| secure: isProduction, |
| sameSite: isProduction ? 'none' : 'lax', |
| maxAge: 24 * 60 * 60 * 1000, |
| ...(isProduction && process.env.COOKIE_DOMAIN && { |
| domain: process.env.COOKIE_DOMAIN |
| }) |
| }); |
|
|
| return token; |
| }; |
|
|
| const adminLogin = asyncHandler(async (req, res) => { |
| const { username, password } = req.body; |
|
|
| if (!username || !password) { |
| res.status(400); |
| throw new Error('Please provide username and password'); |
| } |
|
|
| const admin = await Admin.findOne({ |
| $or: [{ username }, { email: username }] |
| }); |
|
|
| if (!admin) { |
| res.status(401); |
| throw new Error('Invalid credentials'); |
| } |
|
|
| if (!admin.isActive) { |
| res.status(401); |
| throw new Error('Account is deactivated'); |
| } |
|
|
| const isPasswordValid = await admin.checkPassword(password); |
|
|
| if (!isPasswordValid) { |
| res.status(401); |
| throw new Error('Invalid credentials'); |
| } |
|
|
| await Admin.findByIdAndUpdate(admin._id, { lastLogin: new Date() }); |
|
|
| const token = generateAdminToken(res, admin._id); |
|
|
| res.status(200).json({ |
| _id: admin._id, |
| username: admin.username, |
| email: admin.email, |
| firstName: admin.firstName, |
| lastName: admin.lastName, |
| role: admin.role, |
| permissions: admin.permissions, |
| avatar: admin.avatar, |
| token |
| }); |
| }); |
|
|
| const adminLogout = asyncHandler(async (req, res) => { |
| const isProduction = process.env.NODE_ENV === 'production'; |
| |
| res.cookie('adminToken', '', { |
| httpOnly: true, |
| expires: new Date(0), |
| secure: isProduction, |
| sameSite: isProduction ? 'none' : 'lax', |
| ...(isProduction && process.env.COOKIE_DOMAIN && { |
| domain: process.env.COOKIE_DOMAIN |
| }) |
| }); |
|
|
| res.status(200).json({ message: 'Logged out successfully' }); |
| }); |
|
|
| const getAdminProfile = asyncHandler(async (req, res) => { |
| const admin = await Admin.findById(req.admin._id).select('-password'); |
| res.status(200).json(admin); |
| }); |
|
|
| const updateAdminProfile = asyncHandler(async (req, res) => { |
| const { firstName, lastName, email, avatar, preferences } = req.body; |
|
|
| const admin = await Admin.findById(req.admin._id); |
|
|
| if (admin) { |
| admin.firstName = firstName || admin.firstName; |
| admin.lastName = lastName || admin.lastName; |
| admin.email = email || admin.email; |
| admin.avatar = avatar || admin.avatar; |
| admin.preferences = { ...admin.preferences, ...preferences }; |
|
|
| const updatedAdmin = await admin.save(); |
|
|
| res.status(200).json({ |
| _id: updatedAdmin._id, |
| username: updatedAdmin.username, |
| email: updatedAdmin.email, |
| firstName: updatedAdmin.firstName, |
| lastName: updatedAdmin.lastName, |
| role: updatedAdmin.role, |
| permissions: updatedAdmin.permissions, |
| avatar: updatedAdmin.avatar, |
| preferences: updatedAdmin.preferences |
| }); |
| } else { |
| res.status(404); |
| throw new Error('Admin not found'); |
| } |
| }); |
|
|
| const getAllUsers = asyncHandler(async (req, res) => { |
| const page = parseInt(req.query.page) || 1; |
| const limit = parseInt(req.query.limit) || 10; |
| const search = req.query.search || ''; |
| const filter = req.query.filter || 'all'; |
|
|
| const skip = (page - 1) * limit; |
|
|
| const andConditions = []; |
|
|
| if (search) { |
| andConditions.push({ |
| $or: [ |
| { name: { $regex: search, $options: 'i' } }, |
| { email: { $regex: search, $options: 'i' } } |
| ] |
| }); |
| } |
|
|
| if (filter === 'active') { |
| andConditions.push({ |
| $or: [ |
| { isActive: true }, |
| { isActive: { $exists: false } } |
| ] |
| }); |
| } else if (filter === 'inactive') { |
| andConditions.push({ isActive: false }); |
| } |
|
|
| const query = andConditions.length > 0 ? { $and: andConditions } : {}; |
|
|
| const users = await User.find(query) |
| .select('-password') |
| .sort({ createdAt: -1 }) |
| .skip(skip) |
| .limit(limit); |
|
|
| const usersWithDetails = users.map(user => { |
| let recentAddress = '', recentCity = '', recentPhone = ''; |
| if (user.orders && user.orders.length > 0) { |
| |
| const latestOrder = user.orders.reduce((latest, curr) => { |
| return (!latest || (curr.createdAt > latest.createdAt)) ? curr : latest; |
| }, null); |
| if (latestOrder && latestOrder.shippingAddress) { |
| recentAddress = latestOrder.shippingAddress.address || latestOrder.shippingAddress.fullName || ''; |
| recentCity = latestOrder.shippingAddress.city || ''; |
| recentPhone = latestOrder.shippingAddress.phone || ''; |
| } |
| } |
| return { |
| _id: user._id, |
| name: user.name, |
| email: user.email, |
| |
| isActive: typeof user.isActive === 'boolean' ? user.isActive : true, |
| createdAt: user.createdAt, |
| recentAddress, |
| recentCity, |
| recentPhone, |
| country: user.country || '', |
| gender: user.gender || '', |
| dateOfBirth: user.dateOfBirth || '' |
| }; |
| }); |
|
|
| const total = await User.countDocuments(query); |
|
|
| res.status(200).json({ |
| users: usersWithDetails, |
| pagination: { |
| page, |
| limit, |
| total, |
| pages: Math.ceil(total / limit) |
| } |
| }); |
| }); |
|
|
| const getUserById = asyncHandler(async (req, res) => { |
| const user = await User.findById(req.params.id).select('-password'); |
| |
| let recentAddress = '', recentCity = '', recentPhone = ''; |
| if (user && user.orders && user.orders.length > 0) { |
| const latestOrder = user.orders.reduce((latest, curr) => { |
| return (!latest || (curr.createdAt > latest.createdAt)) ? curr : latest; |
| }, null); |
| if (latestOrder && latestOrder.shippingAddress) { |
| recentAddress = latestOrder.shippingAddress.address || latestOrder.shippingAddress.fullName || ''; |
| recentCity = latestOrder.shippingAddress.city || ''; |
| recentPhone = latestOrder.shippingAddress.phone || ''; |
| } |
| } |
|
|
| if (user) { |
| res.status(200).json({ |
| _id: user._id, |
| name: user.name, |
| email: user.email, |
| |
| isActive: typeof user.isActive === 'boolean' ? user.isActive : true, |
| createdAt: user.createdAt, |
| recentAddress, |
| recentCity, |
| recentPhone, |
| country: user.country || '', |
| gender: user.gender || '', |
| dateOfBirth: user.dateOfBirth || '' |
| }); |
| } else { |
| res.status(404); |
| throw new Error('User not found'); |
| } |
| }); |
|
|
| const updateUser = asyncHandler(async (req, res) => { |
| const { name, email, isActive } = req.body; |
|
|
| const user = await User.findById(req.params.id); |
|
|
| if (user) { |
| user.name = name || user.name; |
| user.email = email || user.email; |
| if (typeof isActive === 'boolean') { |
| user.isActive = isActive; |
| } |
|
|
| const updatedUser = await user.save(); |
|
|
| res.status(200).json({ |
| _id: updatedUser._id, |
| name: updatedUser.name, |
| email: updatedUser.email, |
| isActive: updatedUser.isActive |
| }); |
| } else { |
| res.status(404); |
| throw new Error('User not found'); |
| } |
| }); |
|
|
| const deleteUser = asyncHandler(async (req, res) => { |
| const user = await User.findById(req.params.id); |
|
|
| if (user) { |
| await User.findByIdAndDelete(req.params.id); |
| res.status(200).json({ message: 'User deleted successfully' }); |
| } else { |
| res.status(404); |
| throw new Error('User not found'); |
| } |
| }); |
|
|
| const createUser = asyncHandler(async (req, res) => { |
| const { name, email, password, isActive = true } = req.body; |
|
|
| if (!name || !email || !password) { |
| res.status(400); |
| throw new Error('Please provide name, email, and password'); |
| } |
|
|
| const existingUser = await User.findOne({ email }); |
| if (existingUser) { |
| res.status(400); |
| throw new Error('User with this email already exists'); |
| } |
|
|
| const user = await User.create({ |
| name, |
| email, |
| password, |
| isActive, |
| createdAt: new Date(), |
| }); |
|
|
| res.status(201).json({ |
| _id: user._id, |
| name: user.name, |
| email: user.email, |
| isActive: user.isActive, |
| createdAt: user.createdAt |
| }); |
| }); |
|
|
| const getAllProducts = asyncHandler(async (req, res) => { |
| const page = parseInt(req.query.page) || 1; |
| const limit = parseInt(req.query.limit) || 10; |
| const search = req.query.search || ''; |
| const category = req.query.category || ''; |
| const sortBy = req.query.sortBy || 'createdAt'; |
| const sortOrder = req.query.sortOrder || 'desc'; |
|
|
| const skip = (page - 1) * limit; |
|
|
| let query = {}; |
|
|
| if (search) { |
| query.name = { $regex: search, $options: 'i' }; |
| } |
|
|
| if (category) { |
| query.category = category; |
| } |
|
|
| const sortOptions = {}; |
| sortOptions[sortBy] = sortOrder === 'desc' ? -1 : 1; |
|
|
| const products = await ProductModel.find(query) |
| .sort(sortOptions) |
| .skip(skip) |
| .limit(limit); |
|
|
| const total = await ProductModel.countDocuments(query); |
|
|
| res.status(200).json({ |
| products, |
| pagination: { |
| page, |
| limit, |
| total, |
| pages: Math.ceil(total / limit) |
| } |
| }); |
| }); |
|
|
| const createProduct = asyncHandler(async (req, res) => { |
| const { |
| name, |
| price, |
| description, |
| category, |
| seller, |
| stock, |
| images, |
| specifications, |
| warrantyDetails, |
| afterSalesSupport, |
| ratings, |
| numOfReviews, |
| PremiumBadge, |
| reviews |
| } = req.body; |
|
|
| if (!name || !price || !category) { |
| res.status(400); |
| throw new Error('Please provide name, price, and category'); |
| } |
|
|
| await ensureCategoryExists(category); |
|
|
| console.log('Creating product with images:', images); |
|
|
| const product = await ProductModel.create({ |
| name, |
| price, |
| description, |
| category, |
| seller, |
| stock: stock || 0, |
| images: images || [], |
| specifications, |
| warrantyDetails, |
| afterSalesSupport, |
| ratings: ratings , |
| numOfReviews: numOfReviews || 0, |
| PremiumBadge, |
|
|
| reviews: reviews || [] |
| }); |
|
|
| console.log('Product created successfully:', product._id); |
| res.status(201).json(product); |
| }); |
|
|
| const updateProduct = asyncHandler(async (req, res) => { |
| const { |
| name, |
| price, |
| description, |
| category, |
| seller, |
| stock, |
| images, |
| specifications, |
| warrantyDetails, |
| afterSalesSupport, |
| ratings, |
| numOfReviews, |
| PremiumBadge, |
| reviews |
| } = req.body; |
|
|
| const product = await ProductModel.findById(req.params.id); |
|
|
| if (product) { |
| console.log('Updating product with images:', images); |
|
|
| if (category && category !== product.category) { |
| await ensureCategoryExists(category); |
| } |
| |
| product.name = name || product.name; |
| product.price = price || product.price; |
| product.description = description || product.description; |
| product.category = category || product.category; |
| product.seller = seller || product.seller; |
| product.stock = stock !== undefined ? stock : product.stock; |
| product.images = images || product.images; |
| product.specifications = specifications || product.specifications; |
| product.warrantyDetails = warrantyDetails || product.warrantyDetails; |
| product.afterSalesSupport = afterSalesSupport || product.afterSalesSupport; |
| product.ratings = ratings ||product.ratings; |
| product.numOfReviews = numOfReviews !== undefined ? numOfReviews : product.numOfReviews; |
| product.PremiumBadge = PremiumBadge !== undefined ? PremiumBadge : product.PremiumBadge; |
|
|
| product.reviews = reviews || product.reviews; |
|
|
| const updatedProduct = await product.save(); |
| console.log('Product updated successfully:', updatedProduct._id); |
| res.status(200).json(updatedProduct); |
| } else { |
| res.status(404); |
| throw new Error('Product not found'); |
| } |
| }); |
|
|
| const deleteProduct = asyncHandler(async (req, res) => { |
| const product = await ProductModel.findById(req.params.id); |
|
|
| if (product) { |
| await ProductModel.findByIdAndDelete(req.params.id); |
| res.status(200).json({ message: 'Product deleted successfully' }); |
| } else { |
| res.status(404); |
| throw new Error('Product not found'); |
| } |
| }); |
|
|
| const uploadProductImages = asyncHandler(async (req, res) => { |
| try { |
| console.log('Upload request received:', req.files); |
| |
| if (!req.files || req.files.length === 0) { |
| res.status(400); |
| throw new Error('No files uploaded'); |
| } |
|
|
| const uploadedImages = req.files.map(file => { |
| |
| const imagePath = `/images/products/${file.filename}`; |
| console.log('Storing image path in database:', imagePath); |
| return { |
| image: imagePath |
| }; |
| }); |
|
|
| console.log('Uploaded images:', uploadedImages); |
|
|
| res.status(200).json({ |
| success: true, |
| images: uploadedImages, |
| message: `${uploadedImages.length} image(s) uploaded successfully` |
| }); |
| } catch (error) { |
| console.error('Upload error:', error); |
| res.status(500).json({ |
| success: false, |
| message: 'Error uploading images', |
| error: error.message |
| }); |
| } |
| }); |
|
|
| const getDashboardStats = asyncHandler(async (req, res) => { |
| const today = new Date(); |
| const startOfDay = new Date(today.setHours(0, 0, 0, 0)); |
| const startOfWeek = new Date(today.setDate(today.getDate() - today.getDay())); |
| const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1); |
| const startOfYear = new Date(today.getFullYear(), 0, 1); |
|
|
| const [ |
| totalUsers, |
| activeUsers, |
| newUsersToday, |
| newUsersThisWeek, |
| newUsersThisMonth, |
| newUsersThisYear, |
| totalProducts, |
| lowStockProducts, |
| outOfStockProducts, |
| highRatedProducts, |
| topProducts |
| ] = await Promise.all([ |
| User.countDocuments(), |
| |
| User.countDocuments({ $or: [{ isActive: true }, { isActive: { $exists: false } }] }), |
| User.countDocuments({ createdAt: { $gte: startOfDay } }), |
| User.countDocuments({ createdAt: { $gte: startOfWeek } }), |
| User.countDocuments({ createdAt: { $gte: startOfMonth } }), |
| User.countDocuments({ createdAt: { $gte: startOfYear } }), |
| ProductModel.countDocuments(), |
| ProductModel.countDocuments({ stock: { $lt: 10, $gt: 0 } }), |
| ProductModel.countDocuments({ stock: 0 }), |
| ProductModel.countDocuments({ ratings: { $gte: 4 } }), |
| ProductModel.aggregate([ |
| { $sort: { ratings: -1, numOfReviews: -1 } }, |
| { $limit: 8 }, |
| { |
| $project: { |
| name: 1, |
| price: 1, |
| ratings: 1, |
| numOfReviews: 1, |
| stock: 1, |
| category: 1, |
| images: 1 |
| } |
| } |
| ]) |
| ]); |
|
|
| const orderStats = await User.aggregate([ |
| { $unwind: '$orders' }, |
| { |
| $group: { |
| _id: null, |
| totalOrders: { $sum: 1 }, |
| totalRevenue: { $sum: '$orders.amount' }, |
| todayOrders: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfDay] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| todayRevenue: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfDay] }, |
| '$orders.amount', |
| 0 |
| ] |
| } |
| }, |
| weekOrders: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfWeek] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| weekRevenue: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfWeek] }, |
| '$orders.amount', |
| 0 |
| ] |
| } |
| }, |
| monthOrders: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfMonth] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| monthRevenue: { |
| $sum: { |
| $cond: [ |
| { $gte: ['$orders.createdAt', startOfMonth] }, |
| '$orders.amount', |
| 0 |
| ] |
| } |
| }, |
| pendingOrders: { |
| $sum: { |
| $cond: [ |
| { $eq: [{ $toLower: '$orders.status' }, 'placed'] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| processingOrders: { |
| $sum: { |
| $cond: [ |
| { $eq: [{ $toLower: '$orders.status' }, 'processing'] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| shippedOrders: { |
| $sum: { |
| $cond: [ |
| { $eq: [{ $toLower: '$orders.status' }, 'shipped'] }, |
| 1, |
| 0 |
| ] |
| } |
| }, |
| deliveredOrders: { |
| $sum: { |
| $cond: [ |
| { $eq: [{ $toLower: '$orders.status' }, 'delivered'] }, |
| 1, |
| 0 |
| ] |
| } |
| } |
| } |
| } |
| ]); |
|
|
| const stats = orderStats[0] || { |
| totalOrders: 0, |
| totalRevenue: 0, |
| todayOrders: 0, |
| todayRevenue: 0, |
| weekOrders: 0, |
| weekRevenue: 0, |
| monthOrders: 0, |
| monthRevenue: 0, |
| pendingOrders: 0, |
| processingOrders: 0, |
| shippedOrders: 0, |
| deliveredOrders: 0 |
| }; |
|
|
| const recentOrders = await User.aggregate([ |
| { $unwind: '$orders' }, |
| { $sort: { 'orders.createdAt': -1 } }, |
| { $limit: 10 }, |
| { |
| $project: { |
| orderId: '$orders._id', |
| userId: '$_id', |
| userName: '$name', |
| userEmail: '$email', |
| amount: '$orders.amount', |
| status: '$orders.status', |
| createdAt: '$orders.createdAt', |
| items: '$orders.orderItems' |
| } |
| } |
| ]); |
|
|
| const salesTrends = await User.aggregate([ |
| { $unwind: '$orders' }, |
| { |
| $match: { |
| 'orders.createdAt': { |
| $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) |
| } |
| } |
| }, |
| { |
| $group: { |
| _id: { |
| $dateToString: { |
| format: '%Y-%m-%d', |
| date: '$orders.createdAt' |
| } |
| }, |
| orders: { $sum: 1 }, |
| revenue: { $sum: '$orders.amount' } |
| } |
| }, |
| { $sort: { _id: 1 } } |
| ]); |
|
|
| const categoryStats = await ProductModel.aggregate([ |
| { $group: { _id: '$category', count: { $sum: 1 } } }, |
| { $sort: { count: -1 } } |
| ]); |
|
|
| res.status(200).json({ |
| users: { |
| total: totalUsers, |
| active: activeUsers, |
| newToday: newUsersToday, |
| newThisWeek: newUsersThisWeek, |
| newThisMonth: newUsersThisMonth, |
| newThisYear: newUsersThisYear, |
| growthRate: totalUsers > 0 ? ((newUsersThisMonth / totalUsers) * 100).toFixed(2) : 0 |
| }, |
| products: { |
| total: totalProducts, |
| lowStock: lowStockProducts, |
| outOfStock: outOfStockProducts, |
| highRated: highRatedProducts, |
| categories: categoryStats |
| }, |
| orders: { |
| total: stats.totalOrders, |
| totalRevenue: stats.totalRevenue, |
| todayOrders: stats.todayOrders, |
| todayRevenue: stats.todayRevenue, |
| weekOrders: stats.weekOrders, |
| weekRevenue: stats.weekRevenue, |
| monthOrders: stats.monthOrders, |
| monthRevenue: stats.monthRevenue, |
| statusBreakdown: { |
| pending: stats.pendingOrders, |
| processing: stats.processingOrders, |
| shipped: stats.shippedOrders, |
| delivered: stats.deliveredOrders |
| }, |
| averageOrderValue: stats.totalOrders > 0 ? (stats.totalRevenue / stats.totalOrders).toFixed(2) : 0 |
| }, |
| topProducts, |
| latestOrders: recentOrders, |
| salesTrends, |
| systemHealth: { |
| database: 'healthy', |
| uptime: process.uptime(), |
| memory: process.memoryUsage(), |
| timestamp: new Date().toISOString() |
| } |
| }); |
| }); |
|
|
| const getAllOrders = asyncHandler(async (req, res) => { |
| const page = parseInt(req.query.page) || 1; |
| const limit = parseInt(req.query.limit) || 10; |
| const status = req.query.status || 'all'; |
| const period = req.query.period || '30d'; |
|
|
| const skip = (page - 1) * limit; |
|
|
| let startDate; |
| const endDate = new Date(); |
| |
| switch (period) { |
| case '7d': |
| startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000); |
| break; |
| case '30d': |
| startDate = new Date(endDate.getTime() - 30 * 24 * 60 * 60 * 1000); |
| break; |
| case '90d': |
| startDate = new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000); |
| break; |
| default: |
| startDate = new Date(endDate.getTime() - 30 * 24 * 60 * 60 * 1000); |
| } |
|
|
| const users = await User.find({ |
| 'orders.createdAt': { $gte: startDate, $lte: endDate } |
| }); |
|
|
| let allOrders = []; |
| users.forEach(user => { |
| user.orders.forEach(order => { |
| if (order.createdAt >= startDate && order.createdAt <= endDate) { |
| allOrders.push({ |
| _id: order._id, |
| orderId: order._id, |
| userId: user._id, |
| userName: user.name, |
| userEmail: user.email, |
| amount: order.amount, |
| status: order.status, |
| createdAt: order.createdAt, |
| items: order.orderItems || [], |
| shippingAddress: order.shippingAddress, |
| paymentMethod: order.paymentMethod, |
| estimatedDelivery: order.estimatedDelivery, |
| phone: order.shippingAddress?.phone || '', |
| city: order.shippingAddress?.city || '' |
| }); |
| } |
| }); |
| }); |
|
|
| if (status !== 'all') { |
| allOrders = allOrders.filter(order => order.status === status); |
| } |
|
|
| allOrders.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)); |
|
|
| const total = allOrders.length; |
| const orders = allOrders.slice(skip, skip + limit); |
|
|
| res.status(200).json({ |
| orders, |
| pagination: { |
| page, |
| limit, |
| total, |
| pages: Math.ceil(total / limit) |
| } |
| }); |
| }); |
|
|
| const getOrderById = asyncHandler(async (req, res) => { |
| const { id } = req.params; |
| |
| const user = await User.findOne({ 'orders._id': id }); |
| |
| if (!user) { |
| res.status(404); |
| throw new Error('Order not found'); |
| } |
|
|
| const order = user.orders.find(order => order._id.toString() === id); |
| |
| if (order) { |
| res.status(200).json({ |
| order: { |
| ...order.toObject(), |
| userName: user.name, |
| userEmail: user.email, |
| shippingAddress: order.shippingAddress, |
| paymentMethod: order.paymentMethod, |
| estimatedDelivery: order.estimatedDelivery, |
| phone: order.shippingAddress?.phone || '', |
| city: order.shippingAddress?.city || '' |
| } |
| }); |
| } else { |
| res.status(404); |
| throw new Error('Order not found'); |
| } |
| }); |
|
|
| const updateOrder = asyncHandler(async (req, res) => { |
| const { id } = req.params; |
| const { status } = req.body; |
|
|
| const user = await User.findOne({ 'orders._id': id }); |
| |
| if (!user) { |
| res.status(404); |
| throw new Error('Order not found'); |
| } |
|
|
| const orderIndex = user.orders.findIndex(order => order._id.toString() === id); |
| |
| if (orderIndex === -1) { |
| res.status(404); |
| throw new Error('Order not found'); |
| } |
|
|
| user.orders[orderIndex].status = status; |
| await user.save(); |
|
|
| res.status(200).json({ |
| message: 'Order updated successfully', |
| order: user.orders[orderIndex] |
| }); |
| }); |
|
|
| const deleteOrder = asyncHandler(async (req, res) => { |
| const { id } = req.params; |
|
|
| const user = await User.findOne({ 'orders._id': id }); |
| |
| if (!user) { |
| res.status(404); |
| throw new Error('Order not found'); |
| } |
|
|
| user.orders = user.orders.filter(order => order._id.toString() !== id); |
| await user.save(); |
|
|
| res.status(200).json({ message: 'Order deleted successfully' }); |
| }); |
|
|
| const getAnalytics = asyncHandler(async (req, res) => { |
| const { period = '30d' } = req.query; |
| |
| let startDate; |
| const endDate = new Date(); |
| |
| switch (period) { |
| case '7d': |
| startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000); |
| break; |
| case '30d': |
| startDate = new Date(endDate.getTime() - 30 * 24 * 60 * 60 * 1000); |
| break; |
| case '90d': |
| startDate = new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000); |
| break; |
| default: |
| startDate = new Date(endDate.getTime() - 30 * 24 * 60 * 60 * 1000); |
| } |
|
|
| const userGrowth = await User.aggregate([ |
| { |
| $match: { |
| createdAt: { $gte: startDate, $lte: endDate } |
| } |
| }, |
| { |
| $group: { |
| _id: { |
| year: { $year: '$createdAt' }, |
| month: { $month: '$createdAt' }, |
| day: { $dayOfMonth: '$createdAt' } |
| }, |
| count: { $sum: 1 } |
| } |
| }, |
| { $sort: { '_id.year': 1, '_id.month': 1, '_id.day': 1 } } |
| ]); |
|
|
| const allUsers = await User.find({ |
| 'orders.createdAt': { $gte: startDate, $lte: endDate } |
| }); |
|
|
| const revenueData = []; |
| const orderData = []; |
| const categoryRevenue = {}; |
| const productPerformance = {}; |
|
|
| allUsers.forEach(user => { |
| user.orders.forEach(order => { |
| if (order.createdAt >= startDate && order.createdAt <= endDate) { |
| const dateKey = order.createdAt.toISOString().split('T')[0]; |
| const orderAmount = order.amount || 0; |
|
|
| const existingRevenue = revenueData.find(item => item.date === dateKey); |
| if (existingRevenue) { |
| existingRevenue.revenue += orderAmount; |
| } else { |
| revenueData.push({ |
| date: dateKey, |
| revenue: orderAmount |
| }); |
| } |
|
|
| const existingOrder = orderData.find(item => item.date === dateKey); |
| if (existingOrder) { |
| existingOrder.orders += 1; |
| } else { |
| orderData.push({ |
| date: dateKey, |
| orders: 1 |
| }); |
| } |
|
|
| order.orderItems?.forEach(item => { |
| if (item.category) { |
| categoryRevenue[item.category] = (categoryRevenue[item.category] || 0) + (item.price * item.qty); |
| } |
| if (item.productId) { |
| productPerformance[item.productId] = (productPerformance[item.productId] || 0) + (item.price * item.qty); |
| } |
| }); |
| } |
| }); |
| }); |
|
|
| revenueData.sort((a, b) => new Date(a.date) - new Date(b.date)); |
| orderData.sort((a, b) => new Date(a.date) - new Date(b.date)); |
|
|
| const topCategories = Object.entries(categoryRevenue) |
| .map(([category, revenue]) => ({ category, revenue })) |
| .sort((a, b) => b.revenue - a.revenue) |
| .slice(0, 10); |
|
|
| const topProductIds = Object.entries(productPerformance) |
| .sort((a, b) => b[1] - a[1]) |
| .slice(0, 10) |
| .map(([productId]) => productId); |
|
|
| const topProducts = await ProductModel.find({ _id: { $in: topProductIds } }) |
| .select('name price category ratings numOfReviews'); |
|
|
| const userEngagement = await User.aggregate([ |
| { |
| $match: { |
| createdAt: { $gte: startDate, $lte: endDate } |
| } |
| }, |
| { |
| $project: { |
| hasOrders: { $gt: [{ $size: '$orders' }, 0] }, |
| orderCount: { $size: '$orders' }, |
| totalSpent: { $sum: '$orders.amount' }, |
| lastOrderDate: { $max: '$orders.createdAt' } |
| } |
| }, |
| { |
| $group: { |
| _id: null, |
| totalUsers: { $sum: 1 }, |
| usersWithOrders: { $sum: { $cond: ['$hasOrders', 1, 0] } }, |
| avgOrdersPerUser: { $avg: '$orderCount' }, |
| avgSpendingPerUser: { $avg: '$totalSpent' } |
| } |
| } |
| ]); |
|
|
| const geographicData = await User.aggregate([ |
| { |
| $match: { |
| createdAt: { $gte: startDate, $lte: endDate } |
| } |
| }, |
| { |
| $group: { |
| _id: '$shippingAddress.state', |
| count: { $sum: 1 } |
| } |
| }, |
| { $sort: { count: -1 } } |
| ]); |
|
|
| const conversionFunnel = { |
| totalVisitors: userEngagement[0]?.totalUsers || 0, |
| registeredUsers: userEngagement[0]?.totalUsers || 0, |
| usersWithOrders: userEngagement[0]?.usersWithOrders || 0, |
| conversionRate: userEngagement[0]?.totalUsers > 0 |
| ? ((userEngagement[0]?.usersWithOrders / userEngagement[0]?.totalUsers) * 100).toFixed(2) |
| : 0 |
| }; |
|
|
| res.status(200).json({ |
| period, |
| userGrowth, |
| revenueData, |
| orderData, |
| topCategories, |
| topProducts, |
| userEngagement: userEngagement[0] || {}, |
| geographicData, |
| conversionFunnel, |
| summary: { |
| totalRevenue: revenueData.reduce((sum, item) => sum + item.revenue, 0), |
| totalOrders: orderData.reduce((sum, item) => sum + item.orders, 0), |
| avgOrderValue: orderData.reduce((sum, item) => sum + item.orders, 0) > 0 |
| ? (revenueData.reduce((sum, item) => sum + item.revenue, 0) / orderData.reduce((sum, item) => sum + item.orders, 0)).toFixed(2) |
| : 0 |
| } |
| }); |
| }); |
|
|
| const getSystemInfo = asyncHandler(async (req, res) => { |
| const systemInfo = { |
| nodeVersion: process.version, |
| platform: process.platform, |
| memory: process.memoryUsage(), |
| uptime: process.uptime(), |
| environment: process.env.NODE_ENV, |
| database: { |
| connected: mongoose.connection.readyState === 1, |
| host: mongoose.connection.host, |
| name: mongoose.connection.name |
| } |
| }; |
|
|
| res.status(200).json(systemInfo); |
| }); |
|
|
| const getAdminActivityLog = asyncHandler(async (req, res) => { |
| const page = parseInt(req.query.page) || 1; |
| const limit = parseInt(req.query.limit) || 50; |
| const adminId = req.query.adminId; |
|
|
| const skip = (page - 1) * limit; |
|
|
| let query = {}; |
| if (adminId) { |
| query._id = adminId; |
| } |
|
|
| const admins = await Admin.find(query) |
| .select('firstName lastName username activityLog') |
| .sort({ 'activityLog.timestamp': -1 }) |
| .skip(skip) |
| .limit(limit); |
|
|
| const activityLogs = []; |
| admins.forEach(admin => { |
| admin.activityLog.forEach(log => { |
| activityLogs.push({ |
| adminName: admin.getFullName(), |
| adminUsername: admin.username, |
| ...log.toObject() |
| }); |
| }); |
| }); |
|
|
| activityLogs.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp)); |
|
|
| res.status(200).json({ |
| activityLogs: activityLogs.slice(0, limit), |
| pagination: { |
| page, |
| limit, |
| total: activityLogs.length |
| } |
| }); |
| }); |
|
|
| const getAllCategories = asyncHandler(async (req, res) => { |
| const categories = await ProductModel.distinct('category'); |
| |
| res.status(200).json({ |
| success: true, |
| categories: categories.sort() |
| }); |
| }); |
|
|
| const createCategory = asyncHandler(async (req, res) => { |
| const { name } = req.body; |
|
|
| if (!name || name.trim() === '') { |
| res.status(400); |
| throw new Error('Category name is required'); |
| } |
|
|
| const trimmedName = name.trim(); |
|
|
| const existingCategory = await ProductModel.findOne({ category: trimmedName }); |
| if (existingCategory) { |
| res.status(400); |
| throw new Error('Category already exists'); |
| } |
|
|
| res.status(201).json({ |
| success: true, |
| message: 'Category created successfully', |
| category: trimmedName |
| }); |
| }); |
|
|
| const ensureCategoryExists = async (categoryName) => { |
| if (!categoryName || categoryName.trim() === '') { |
| return false; |
| } |
|
|
| const trimmedName = categoryName.trim(); |
|
|
| const existingCategory = await ProductModel.findOne({ category: trimmedName }); |
| if (existingCategory) { |
| return true; |
| } |
|
|
| return true; |
| }; |
|
|
| module.exports = { |
| adminLogin, |
| adminLogout, |
| getAdminProfile, |
| updateAdminProfile, |
| getAllUsers, |
| getUserById, |
| updateUser, |
| deleteUser, |
| createUser, |
| getAllProducts, |
| createProduct, |
| updateProduct, |
| deleteProduct, |
| uploadProductImages, |
| getAllOrders, |
| getOrderById, |
| updateOrder, |
| deleteOrder, |
| getDashboardStats, |
| getAnalytics, |
| getSystemInfo, |
| getAdminActivityLog, |
| getAllCategories, |
| createCategory |
| }; |
