Download server.js from ismizo/CVBora: direct link, hf CLI and curl.
- Browser
- Download file 29.1 kB
-
https://huggingface.co/spaces/ismizo/CVBora/resolve/main/server.js
- Command line
-
hf download hf://spaces/ismizo/CVBora/server.js
-
curl -L -o server.js https://huggingface.co/spaces/ismizo/CVBora/resolve/main/server.js
29.1 kB
| require('dotenv').config(); | |
| const express = require('express'); | |
| const axios = require('axios'); | |
| const mongoose = require('mongoose'); | |
| const cors = require('cors'); | |
| const passport = require('./config/passport'); | |
| const jwt = require('jsonwebtoken'); | |
| const checkQuota = require('./middleware/quota'); | |
| const crypto = require('crypto'); | |
| const path = require('path'); | |
| const { generateCV, builderChat } = require('./services/aiService'); | |
| const { createPdfFromHtml } = require('./services/pdfService'); | |
| const { createWordFromHtml } = require('./services/wordService'); | |
| const { getClickPesaAuthToken, initiateClickPesaUssdPush } = require('./services/clickpesaService'); | |
| const { uploadFile, uploadText, deleteFile, listFiles, getPresignedUrl, getFileContent, userPrefix, USER_QUOTA_BYTES } = require('./services/r2Service'); | |
| const Transaction = require('./models/Transaction'); | |
| const User = require('./models/User'); | |
| const ManualPayment = require('./models/ManualPayment'); | |
| const GenerationLog = require('./models/GenerationLog'); | |
| const app = express(); | |
| const PORT = process.env.PORT || 7860; | |
| app.set('trust proxy', 1); | |
| const multer = require('multer'); | |
| const { extractText } = require('./utils/fileParser'); | |
| const storage = multer.memoryStorage(); | |
| const upload = multer({ | |
| storage, | |
| limits: { fileSize: 150 * 1024 * 1024 } | |
| }); | |
| app.use(express.json({ limit: '50mb' })); | |
| app.use(cors()); | |
| app.use(passport.initialize()); | |
| mongoose.connect(process.env.MONGO_URI) | |
| .then(() => console.log('β MongoDB Connected')) | |
| .catch(err => console.error('β MongoDB Error:', err)); | |
| // βββ HELPERS ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| const verifyToken = async (req, res, next) => { | |
| const token = req.headers['authorization']; | |
| if (!token) return res.status(403).send("A token is required"); | |
| try { | |
| const decoded = jwt.verify(token.split(" ")[1], process.env.JWT_SECRET); | |
| req.user = decoded; | |
| const user = await User.findById(decoded.id); | |
| if (user && user.isBanned) { | |
| return res.status(403).json({ error: "Your account has been banned." }); | |
| } | |
| req.userObject = user; | |
| } catch (err) { | |
| return res.status(401).send("Invalid Token"); | |
| } | |
| return next(); | |
| }; | |
| async function getProfessionalSummary(githubUrl, linkedinUrl) { | |
| const results = { github: null, linkedin: null }; | |
| if (githubUrl) { | |
| try { | |
| const username = githubUrl.split('/').pop(); | |
| const response = await axios.get(`https://api.github.com/users/${username}/repos`, { | |
| params: { sort: 'updated', per_page: 5 }, | |
| headers: { 'User-Agent': 'NodeJS-Profile-Fetcher' } | |
| }); | |
| results.github = response.data.map(repo => ({ | |
| name: repo.name, | |
| description: repo.description || "No description provided.", | |
| lastUpdated: repo.updated_at, | |
| url: repo.html_url | |
| })); | |
| } catch { | |
| results.github = { error: "Could not fetch GitHub data." }; | |
| } | |
| } | |
| if (linkedinUrl) { | |
| try { | |
| const response = await axios.post(`https://ismizo-puppeteer.hf.space/api/v1/task/snapshot`, { url: linkedinUrl }); | |
| results.linkedin = response.data; | |
| } catch { | |
| results.linkedin = { error: "LinkedIn fetch failed." }; | |
| } | |
| } | |
| return results; | |
| } | |
| // βββ AUTH ROUTES βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] })); | |
| app.get('/auth/google/callback', | |
| passport.authenticate('google', { session: false, failureRedirect: '/' }), | |
| (req, res) => { | |
| const token = jwt.sign({ id: req.user._id, email: req.user.email }, process.env.JWT_SECRET, { expiresIn: '7d' }); | |
| res.redirect(`${process.env.FRONTEND_URL}/?token=${token}`); | |
| } | |
| ); | |
| app.get('/auth/linkedin', passport.authenticate('linkedin', { state: 'SOME STATE' })); | |
| app.get('/auth/linkedin/callback', | |
| passport.authenticate('linkedin', { session: false, failureRedirect: '/' }), | |
| (req, res) => { | |
| const token = jwt.sign({ id: req.user._id, email: req.user.email }, process.env.JWT_SECRET, { expiresIn: '7d' }); | |
| res.redirect(`${process.env.FRONTEND_URL}/?token=${token}`); | |
| } | |
| ); | |
| // βββ USER PROFILE βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.get('/api/me', verifyToken, async (req, res) => { | |
| const user = await User.findById(req.user.id); | |
| res.json({ | |
| ...user.toObject(), | |
| storageQuotaBytes: USER_QUOTA_BYTES, | |
| }); | |
| }); | |
| // βββ EXTRACT RESUME TEXT ββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/extract-resume', verifyToken, upload.single('resume'), async (req, res) => { | |
| try { | |
| if (!req.file) return res.status(400).json({ error: 'No file uploaded' }); | |
| const text = await extractText(req.file.buffer, req.file.mimetype); | |
| res.json({ success: true, filename: req.file.originalname, extractedText: text.trim() }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| // βββ GENERATE CV ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| const uploadFields = upload.fields([ | |
| { name: 'resumeFiles', maxCount: 1 }, | |
| { name: 'jobDescImages', maxCount: 3 } | |
| ]); | |
| app.post('/api/generate-cv', verifyToken, checkQuota, uploadFields, async (req, res) => { | |
| try { | |
| const { jobDescText, instructions, resumeText, linkedInUrl, githubUrl } = req.body; | |
| // 1. Process resume file | |
| let processedResumeImages = []; | |
| let uploadedResumeKey = null; | |
| if (req.files['resumeFiles']) { | |
| const file = req.files['resumeFiles'][0]; | |
| // Save to R2 | |
| const user = req.userObject; | |
| const remaining = USER_QUOTA_BYTES - user.storageUsedBytes; | |
| if (file.size <= remaining) { | |
| const timestamp = Date.now(); | |
| uploadedResumeKey = `${userPrefix(req.user.id, 'uploads')}${timestamp}_${file.originalname}`; | |
| await uploadFile(uploadedResumeKey, file.buffer, file.mimetype); | |
| user.storageUsedBytes = Math.max(0, user.storageUsedBytes + file.size); | |
| // Will save later after credit deduction | |
| } | |
| if (file.mimetype === 'application/pdf') { | |
| const imageBuffers = await extractText(file.buffer, file.mimetype).then(data => data.pageImages); | |
| processedResumeImages = imageBuffers.map(buf => ({ buffer: buf, mimetype: 'image/png' })); | |
| } else if (file.mimetype.startsWith('image/')) { | |
| processedResumeImages = [{ buffer: file.buffer, mimetype: file.mimetype }]; | |
| } | |
| } | |
| let jobImages = []; | |
| if (req.files['jobDescImages']) { | |
| jobImages = req.files['jobDescImages']; | |
| } | |
| if (processedResumeImages.length === 0 && !resumeText && !linkedInUrl && !githubUrl) { | |
| return res.status(400).json({ error: "Please provide a Resume File, Paste Text, or Profile Links." }); | |
| } | |
| const professionalSummary = await getProfessionalSummary(githubUrl, linkedInUrl); | |
| console.log(`Generating CV (${req.usageType})...`); | |
| // 2. Call AI β now returns cv_html + cover_letter_html | |
| const generatedData = await generateCV( | |
| processedResumeImages, | |
| jobImages, | |
| jobDescText, | |
| instructions, | |
| { github: professionalSummary.github, linkedin: professionalSummary.linkedin, resumeText } | |
| ); | |
| // 3. Save generated HTML files to R2 | |
| const user = req.userObject; | |
| const timestamp = Date.now(); | |
| const name = (generatedData.personal_info?.name || 'cv').replace(/\s+/g, '_'); | |
| const cvKey = `${userPrefix(req.user.id, 'generated')}${timestamp}_${name}_CV.html`; | |
| const clKey = `${userPrefix(req.user.id, 'generated')}${timestamp}_${name}_CoverLetter.html`; | |
| const cvHtmlSize = Buffer.byteLength(generatedData.cv_html || '', 'utf-8'); | |
| const clHtmlSize = Buffer.byteLength(generatedData.cover_letter_html || '', 'utf-8'); | |
| const totalNewSize = cvHtmlSize + clHtmlSize; | |
| const remaining = USER_QUOTA_BYTES - user.storageUsedBytes; | |
| if (totalNewSize <= remaining) { | |
| await Promise.all([ | |
| uploadText(cvKey, generatedData.cv_html), | |
| uploadText(clKey, generatedData.cover_letter_html), | |
| ]); | |
| user.storageUsedBytes = Math.max(0, user.storageUsedBytes + totalNewSize); | |
| } | |
| // 4. Deduct credits | |
| if (req.usageType === 'free') user.freeGenerationsUsed += 1; | |
| else user.paidCredits -= 1; | |
| user.lastGenerationDate = new Date(); | |
| await user.save(); | |
| // 5. Persist generation log | |
| try { | |
| const jobTitleMatch = (instructions || '').match(/(?:for|applying|role|position)[:\s]+([\w\s]+)/i); | |
| await GenerationLog.create({ | |
| userId: req.user.id, | |
| email: user.email || '', | |
| type: req.usageType === 'free' ? 'free' : 'paid', | |
| jobTitle: jobTitleMatch ? jobTitleMatch[1].trim().slice(0, 80) : '', | |
| }); | |
| } catch (logErr) { | |
| console.warn('GenerationLog write failed (non-fatal):', logErr.message); | |
| } | |
| res.json({ | |
| success: true, | |
| data: generatedData, | |
| savedFiles: { | |
| resume: uploadedResumeKey, | |
| cv: cvKey, | |
| coverLetter: clKey, | |
| }, | |
| remainingFree: 2 - user.freeGenerationsUsed, | |
| remainingPaid: user.paidCredits | |
| }); | |
| } catch (error) { | |
| console.error(error); | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| // βββ CONVERSATIONAL BUILDER βββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/builder/message', verifyToken, async (req, res) => { | |
| try { | |
| const { messages } = req.body; | |
| if (!Array.isArray(messages)) return res.status(400).json({ error: 'messages array required' }); | |
| const result = await builderChat(messages); | |
| res.json(result); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| // βββ USER FILES API βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.get('/api/files', verifyToken, async (req, res) => { | |
| try { | |
| const uploadsPrefix = userPrefix(req.user.id, 'uploads'); | |
| const generatedPrefix = userPrefix(req.user.id, 'generated'); | |
| const [uploads, generated] = await Promise.all([ | |
| listFiles(uploadsPrefix), | |
| listFiles(generatedPrefix), | |
| ]); | |
| const toFileObj = (obj, type) => ({ | |
| key: obj.key, | |
| name: path.basename(obj.key), | |
| size: obj.size, | |
| lastModified: obj.lastModified, | |
| type, // 'upload' | 'generated' | |
| }); | |
| const files = [ | |
| ...uploads.map(f => toFileObj(f, 'upload')), | |
| ...generated.map(f => toFileObj(f, 'generated')), | |
| ].sort((a, b) => new Date(b.lastModified) - new Date(a.lastModified)); | |
| const user = await User.findById(req.user.id); | |
| res.json({ | |
| files, | |
| storageUsedBytes: user.storageUsedBytes, | |
| storageQuotaBytes: USER_QUOTA_BYTES, | |
| }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| app.delete('/api/files', verifyToken, async (req, res) => { | |
| try { | |
| const { key } = req.body; | |
| if (!key) return res.status(400).json({ error: 'key required' }); | |
| // Security: ensure the key belongs to this user | |
| const expectedPrefix = `cvbora/users/${req.user.id}/`; | |
| if (!key.startsWith(expectedPrefix)) { | |
| return res.status(403).json({ error: 'Forbidden' }); | |
| } | |
| const { getObjectSize } = require('./services/r2Service'); | |
| const fileSize = await getObjectSize(key); | |
| await deleteFile(key); | |
| const user = await User.findById(req.user.id); | |
| user.storageUsedBytes = Math.max(0, user.storageUsedBytes - fileSize); | |
| await user.save(); | |
| res.json({ success: true }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| app.post('/api/files/download-url', verifyToken, async (req, res) => { | |
| try { | |
| const { key } = req.body; | |
| if (!key) return res.status(400).json({ error: 'key required' }); | |
| const expectedPrefix = `cvbora/users/${req.user.id}/`; | |
| if (!key.startsWith(expectedPrefix)) { | |
| return res.status(403).json({ error: 'Forbidden' }); | |
| } | |
| const url = await getPresignedUrl(key, 3600); | |
| res.json({ url }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| // βββ PDF DOWNLOAD βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/download-pdf', verifyToken, async (req, res) => { | |
| try { | |
| const { html, filename } = req.body; | |
| if (!html) return res.status(400).json({ error: 'html field required' }); | |
| const pdfBuffer = await createPdfFromHtml(html); | |
| res.set({ | |
| 'Content-Type': 'application/pdf', | |
| 'Content-Length': pdfBuffer.length, | |
| 'Content-Disposition': `attachment; filename="${filename || 'document'}.pdf"`, | |
| }); | |
| res.send(pdfBuffer); | |
| } catch (error) { | |
| console.error("PDF Error:", error); | |
| res.status(500).json({ error: "Failed to generate PDF" }); | |
| } | |
| }); | |
| // βββ WORD DOWNLOAD ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/download-word', verifyToken, async (req, res) => { | |
| try { | |
| const { html, filename } = req.body; | |
| if (!html) return res.status(400).json({ error: 'html field required' }); | |
| const docxBuffer = await createWordFromHtml(html, filename || 'CV_Document'); | |
| res.set({ | |
| 'Content-Type': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', | |
| 'Content-Length': docxBuffer.length, | |
| 'Content-Disposition': `attachment; filename="${filename || 'document'}.docx"`, | |
| }); | |
| res.send(docxBuffer); | |
| } catch (error) { | |
| console.error("Word Error:", error); | |
| res.status(500).json({ error: "Failed to generate Word document" }); | |
| } | |
| }); | |
| // βββ CONVERT SAVED HTML FILE βββββββββββββββββββββββββββββββββββββββββββββββββ | |
| // Fetches a saved .html file from R2 by key and converts it to PDF or DOCX. | |
| app.post('/api/convert-saved', verifyToken, async (req, res) => { | |
| try { | |
| const { key, format } = req.body; // format: 'pdf' | 'word' | |
| if (!key || !format) return res.status(400).json({ error: 'key and format required' }); | |
| // Security: only allow files owned by this user | |
| const expectedPrefix = `cvbora/users/${req.user.id}/`; | |
| if (!key.startsWith(expectedPrefix)) { | |
| return res.status(403).json({ error: 'Forbidden' }); | |
| } | |
| // Only allow HTML files | |
| if (!key.toLowerCase().endsWith('.html')) { | |
| return res.status(400).json({ error: 'Only HTML files can be converted' }); | |
| } | |
| // Fetch HTML content from R2 | |
| const htmlBuffer = await getFileContent(key); | |
| const html = htmlBuffer.toString('utf-8'); | |
| const path = require('path'); | |
| const baseName = path.basename(key, '.html'); | |
| if (format === 'pdf') { | |
| const pdfBuffer = await createPdfFromHtml(html); | |
| res.set({ | |
| 'Content-Type': 'application/pdf', | |
| 'Content-Length': pdfBuffer.length, | |
| 'Content-Disposition': `attachment; filename="${baseName}.pdf"`, | |
| }); | |
| return res.send(pdfBuffer); | |
| } | |
| if (format === 'word') { | |
| const docxBuffer = await createWordFromHtml(html, baseName); | |
| res.set({ | |
| 'Content-Type': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', | |
| 'Content-Length': docxBuffer.length, | |
| 'Content-Disposition': `attachment; filename="${baseName}.docx"`, | |
| }); | |
| return res.send(docxBuffer); | |
| } | |
| res.status(400).json({ error: 'Invalid format. Use pdf or word.' }); | |
| } catch (error) { | |
| console.error('Convert-saved Error:', error); | |
| res.status(500).json({ error: 'Conversion failed. Please try again.' }); | |
| } | |
| }); | |
| // βββ PAYMENT ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/pay', verifyToken, async (req, res) => { | |
| try { | |
| const { phoneNumber } = req.body; | |
| const shortRef = crypto.randomBytes(6).toString('hex'); | |
| const newTransaction = new Transaction({ | |
| shortReference: shortRef, | |
| userId: req.user.id, | |
| amount: 908 | |
| }); | |
| await newTransaction.save(); | |
| const payload = { | |
| payment_method: "mobile_money", | |
| amount: 908, | |
| currency: "TZS", | |
| phoneNumber, | |
| orderReference: shortRef | |
| }; | |
| const authToken = await getClickPesaAuthToken(process.env.CLICKPESA_USER_ID, process.env.CLICKPESA_API_KEY); | |
| const response = await initiateClickPesaUssdPush(authToken, payload); | |
| if (response && response.status === 'PROCESSING') { | |
| res.json({ | |
| success: true, | |
| message: `Payment initiated. User: ${req.user.id} at ${new Date().toLocaleString()}. You should receive a USSD prompt shortly.` | |
| //orderReference: shortRef | |
| }); | |
| } else { | |
| console.error("Unexpected ClickPesa response:", response); | |
| res.status(500).json({ success: false, error: "Payment initiation failed. Please try again." }); | |
| } | |
| } catch (error) { | |
| console.error("Payment Error:", error); | |
| res.status(500).json({ error: "Payment initiation failed" }); | |
| } | |
| }); | |
| app.post('/api/webhook/clickpesa', async (req, res) => { | |
| try { | |
| const { event, data } = req.body; | |
| if (!data || !data.orderReference) return res.status(400).send("Invalid payload"); | |
| const { status, orderReference, message, id: clickPesaId } = data; | |
| const transaction = await Transaction.findOne({ shortReference: orderReference }); | |
| if (!transaction) return res.status(200).send("OK"); | |
| transaction.status = status; | |
| await transaction.save(); | |
| if (status === 'SUCCESS' || status === 'SETTLED') { | |
| const user = await User.findById(transaction.userId); | |
| if (user && !transaction.isProcessed) { | |
| user.paidCredits += 5; | |
| transaction.isProcessed = true; | |
| await user.save(); | |
| await transaction.save(); | |
| console.log(`β Credits added to ${user.email}`); | |
| } | |
| } else if (status === 'REFUNDED' || status === 'REVERSED') { | |
| const user = await User.findById(transaction.userId); | |
| if (user && user.paidCredits >= 5) { | |
| user.paidCredits -= 5; | |
| await user.save(); | |
| } | |
| } | |
| res.status(200).send("OK"); | |
| } catch (error) { | |
| console.error("Webhook Error:", error); | |
| res.status(500).send("Internal Server Error"); | |
| } | |
| }); | |
| // βββ MANUAL MPESA PAYMENT ββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app.post('/api/pay/manual', verifyToken, upload.single('screenshot'), async (req, res) => { | |
| try { | |
| const { transactionId } = req.body; | |
| const file = req.file; | |
| if (!file && !transactionId) { | |
| return res.status(400).json({ error: 'Please provide either a screenshot or a transaction ID.' }); | |
| } | |
| let screenshotKey = null; | |
| if (file) { | |
| const timestamp = Date.now(); | |
| screenshotKey = `cvbora/payments/mpesa_${req.user.id}_${timestamp}_${file.originalname}`; | |
| await uploadFile(screenshotKey, file.buffer, file.mimetype); | |
| } | |
| const newPayment = new ManualPayment({ | |
| userId: req.user.id, | |
| screenshotKey, | |
| transactionId, | |
| amount: 908 | |
| }); | |
| await newPayment.save(); | |
| res.json({ success: true, message: 'Payment submitted for review.' }); | |
| } catch (error) { | |
| console.error("Manual Payment Error:", error); | |
| res.status(500).json({ error: "Submission failed." }); | |
| } | |
| }); | |
| // βββ ADMIN ENDPOINTS βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| const requireAdmin = async (req, res, next) => { | |
| if (!req.userObject || !req.userObject.isAdmin) { | |
| return res.status(403).json({ error: "Admin access required." }); | |
| } | |
| next(); | |
| }; | |
| app.get('/api/admin/payments', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const payments = await ManualPayment.find({ status: 'pending' }).populate('userId', 'email displayName'); | |
| // Add presigned URLs for screenshots | |
| const paymentsWithUrl = await Promise.all(payments.map(async (p) => { | |
| let url = null; | |
| if (p.screenshotKey) { | |
| url = await getPresignedUrl(p.screenshotKey, 3600); | |
| } | |
| return { ...p.toObject(), screenshotUrl: url }; | |
| })); | |
| res.json(paymentsWithUrl); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| app.post('/api/admin/payments/approve/:id', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const payment = await ManualPayment.findById(req.params.id); | |
| if (!payment) return res.status(404).json({ error: 'Not found' }); | |
| if (payment.status === 'pending') { | |
| payment.status = 'approved'; | |
| payment.reviewedAt = new Date(); | |
| await payment.save(); | |
| const user = await User.findById(payment.userId); | |
| if (user) { | |
| user.paidCredits += 3; | |
| await user.save(); | |
| } | |
| } | |
| res.json({ success: true }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| app.post('/api/admin/payments/reject/:id', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const payment = await ManualPayment.findById(req.params.id); | |
| if (!payment) return res.status(404).json({ error: 'Not found' }); | |
| payment.status = 'rejected'; | |
| payment.reviewedAt = new Date(); | |
| await payment.save(); | |
| res.json({ success: true }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| app.get('/api/admin/users', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const q = req.query.search || ''; | |
| const page = Math.max(1, parseInt(req.query.page) || 1); | |
| const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 20)); | |
| const skip = (page - 1) * limit; | |
| const query = q ? { email: { $regex: q, $options: 'i' } } : {}; | |
| const [users, total] = await Promise.all([ | |
| User.find(query).sort({ _id: -1 }).skip(skip).limit(limit).lean(), | |
| User.countDocuments(query), | |
| ]); | |
| res.json({ | |
| users, | |
| total, | |
| page, | |
| totalPages: Math.ceil(total / limit), | |
| }); | |
| } catch(err) { | |
| res.status(500).json({ error: err.message }); | |
| } | |
| }); | |
| // βββ ADMIN ACTIVITY LOGS βββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| // Returns a unified, time-sorted feed of: GenerationLog + ManualPayment + Transaction | |
| app.get('/api/admin/logs', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const page = Math.max(1, parseInt(req.query.page) || 1); | |
| const limit = Math.min(200, Math.max(1, parseInt(req.query.limit) || 30)); | |
| const filter = req.query.type || 'all'; // 'all' | 'generation' | 'payment' | 'manual' | |
| const sources = []; | |
| if (filter === 'all' || filter === 'generation') { | |
| const logs = await GenerationLog.find({}).lean(); | |
| logs.forEach(l => sources.push({ | |
| _id: l._id, | |
| type: 'generation', | |
| subtype: l.type, // 'free' | 'paid' | |
| userId: l.userId, | |
| email: l.email || '', | |
| amount: null, | |
| status: null, | |
| detail: l.jobTitle || '', | |
| createdAt: l.createdAt, | |
| })); | |
| } | |
| if (filter === 'all' || filter === 'payment') { | |
| const txns = await Transaction.find({}).populate('userId', 'email').lean(); | |
| txns.forEach(t => sources.push({ | |
| _id: t._id, | |
| type: 'payment', | |
| subtype: 'clickpesa', | |
| userId: t.userId, | |
| email: t.userId?.email || '', | |
| amount: t.amount, | |
| status: t.status, | |
| detail: t.shortReference || '', | |
| createdAt: t.createdAt, | |
| })); | |
| } | |
| if (filter === 'all' || filter === 'manual') { | |
| const manuals = await ManualPayment.find({}).populate('userId', 'email').lean(); | |
| manuals.forEach(m => sources.push({ | |
| _id: m._id, | |
| type: 'manual_payment', | |
| subtype: m.status, // 'pending' | 'approved' | 'rejected' | |
| userId: m.userId, | |
| email: m.userId?.email || '', | |
| amount: m.amount, | |
| status: m.status, | |
| detail: m.transactionId || '', | |
| createdAt: m.uploadedAt, | |
| })); | |
| } | |
| // Sort descending, then paginate | |
| sources.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)); | |
| const total = sources.length; | |
| const paginated = sources.slice((page - 1) * limit, page * limit); | |
| res.json({ | |
| logs: paginated, | |
| total, | |
| page, | |
| totalPages: Math.ceil(total / limit), | |
| }); | |
| } catch(err) { | |
| res.status(500).json({ error: err.message }); | |
| } | |
| }); | |
| app.post('/api/admin/users/:id/ban', verifyToken, requireAdmin, async (req, res) => { | |
| try { | |
| const user = await User.findById(req.params.id); | |
| if (!user) return res.status(404).json({ error: 'Not found' }); | |
| user.isBanned = !user.isBanned; // toggle ban | |
| await user.save(); | |
| res.json({ success: true, isBanned: user.isBanned }); | |
| } catch (error) { | |
| res.status(500).json({ error: error.message }); | |
| } | |
| }); | |
| // Health Check | |
| app.get('/api/health', (req, res) => { | |
| res.json({ | |
| status: 'ok', | |
| message: 'The CVBora backend is running smoothly!', | |
| timestamp: new Date() | |
| }); | |
| }); | |
| app.get('/api/dev/add-credits6942', verifyToken, async (req, res) => { | |
| const user = await User.findById(req.user.id); | |
| user.paidCredits += 10; | |
| await user.save(); | |
| res.json({ success: true, newBalance: user.paidCredits }); | |
| }); | |
| app.listen(PORT, () => { | |
| console.log(`π Server running on port ${PORT}`); | |
| }); | |