CVBora / server.js
ismizo's picture
Upload server.js
de2158e verified
Raw History Blame Contribute Delete
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}`);
});