tenderizer / src /controllers /tenderController.js
ismizo's picture
Upload 28 files
268ef75 verified
Raw History Blame Contribute Delete
27.9 kB
import Tender from '../models/Tender.js';
import { uploadToR2, getFileStream, getFileObject } from '../utils/storageUtils.js';
import User from '../models/User.js';
import ActivityLog from '../models/ActivityLog.js';
import {
analyzeDocuments,
generateDraftingPlan,
generateDocumentContent,
refineDocumentContent,
generateSubmissionInstructions,
mergeHtmlParts,
checkExistingDocuments,
labelUploadedFile
} from '../services/aiService.js';
// Credit costs
const CREDITS = {
FULL_PROCESS: 10, // Analysis + Planning + All Documents
REFINE_DOCUMENT: 2 // Each rewrite
};
// @desc Create a new Tender Project
// @route POST /api/tenders
export const createTender = async (req, res) => {
try {
const { title, description, companyName } = req.body;
const tender = await Tender.create({
user: req.user._id,
title,
description,
companyName: companyName || ''
});
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'CREATE_TENDER',
tenderId: tender._id,
tenderTitle: tender.title,
details: { title }
});
res.status(201).json(tender);
} catch (error) {
res.status(500).json({ message: 'Server Error', error: error.message });
}
};
// @desc Get all tenders for current user
// @route GET /api/tenders
export const getMyTenders = async (req, res) => {
try {
const tenders = await Tender.find({ user: req.user._id }).sort({ createdAt: -1 });
res.json(tenders);
} catch (error) {
res.status(500).json({ message: 'Server Error' });
}
};
// @desc Get single tender details
// @route GET /api/tenders/:id
export const getTenderById = async (req, res) => {
try {
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
res.json(tender);
} catch (error) {
res.status(500).json({ message: 'Server Error' });
}
};
// @desc Upload a file to a tender
// @route POST /api/tenders/:id/upload
export const uploadTenderFile = async (req, res) => {
try {
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
if (!req.files || req.files.length === 0) {
return res.status(400).json({ message: 'No files uploaded' });
}
for (const file of req.files) {
const key = await uploadToR2(file.buffer, file.originalname, file.mimetype);
// Label the file with AI (non-blocking — upload always succeeds even if labeling fails)
let aiLabel = 'Uploaded Document';
let aiDescription = '';
let documentCategory = 'other';
let fileCompanyName = '';
try {
const labelResult = await labelUploadedFile(file.buffer, file.mimetype, file.originalname);
aiLabel = labelResult.label || aiLabel;
aiDescription = labelResult.description || '';
documentCategory = labelResult.documentCategory || 'other';
// Auto-populate companyName from AI detection, fall back to tender's company
fileCompanyName = labelResult.detectedCompanyName || (documentCategory === 'company' ? (tender.companyName || '') : '');
console.log(`Labeled "${file.originalname}" as: [${documentCategory}] ${aiLabel}${fileCompanyName ? ` (${fileCompanyName})` : ''}`);
} catch (labelErr) {
console.warn('Could not label file:', file.originalname, labelErr.message);
}
tender.inputFiles.push({
originalName: file.originalname,
storageKey: key,
mimeType: file.mimetype,
size: file.size,
documentCategory,
companyName: fileCompanyName,
aiLabel,
aiDescription
});
}
await tender.save();
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'UPLOAD_FILES',
tenderId: tender._id,
tenderTitle: tender.title,
details: { fileCount: req.files.length, fileNames: req.files.map(f => f.originalname) }
});
res.status(201).json(tender);
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Upload failed' });
}
};
// @desc Get unique library files uploaded by the user across all tenders
// @route GET /api/tenders/library
export const getUserLibraryFiles = async (req, res) => {
try {
const tenders = await Tender.find({ user: req.user._id }).select('inputFiles');
const uniqueFilesMap = new Map();
tenders.forEach(tender => {
tender.inputFiles.forEach(file => {
if (!uniqueFilesMap.has(file.storageKey)) {
uniqueFilesMap.set(file.storageKey, file);
}
});
});
const libraryFiles = Array.from(uniqueFilesMap.values())
.sort((a, b) => new Date(b.uploadedAt) - new Date(a.uploadedAt));
res.json(libraryFiles);
} catch (error) {
console.error("Library Fetch Error:", error);
res.status(500).json({ message: 'Failed to fetch library files' });
}
};
// @desc Attach previously uploaded files to a tender
// @route POST /api/tenders/:id/attach-library
export const attachLibraryFiles = async (req, res) => {
try {
const { files } = req.body;
if (!files || files.length === 0) {
return res.status(400).json({ message: 'No files selected to attach' });
}
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
files.forEach(file => {
const isDuplicate = tender.inputFiles.some(existing => existing.storageKey === file.storageKey);
if (!isDuplicate) {
// Preserve documentCategory, companyName, aiLabel, aiDescription from library
tender.inputFiles.push({
originalName: file.originalName,
aiDescription: file.aiDescription || '',
aiLabel: file.aiLabel || '',
documentCategory: ['call', 'company', 'other'].includes(file.documentCategory) ? file.documentCategory : 'other',
companyName: file.companyName || '',
storageKey: file.storageKey,
mimeType: file.mimeType,
size: file.size,
uploadedAt: Date.now()
});
}
});
await tender.save();
res.status(200).json(tender);
} catch (error) {
console.error("Attach Library Error:", error);
res.status(500).json({ message: 'Failed to attach files' });
}
};
// @desc Proxy file download (Securely fetch from R2)
// @route GET /api/tenders/file/proxy
export const getFileProxy = async (req, res) => {
try {
const key = req.query.key;
const { Body, ContentType } = await getFileObject(key);
if (ContentType) {
res.setHeader('Content-Type', ContentType);
} else {
if (key.endsWith('.html')) res.setHeader('Content-Type', 'text/html');
else if (key.endsWith('.pdf')) res.setHeader('Content-Type', 'application/pdf');
}
res.setHeader('Content-Disposition', 'inline');
Body.pipe(res);
} catch (error) {
console.error("Proxy Error:", error);
res.status(404).json({ message: 'File not found' });
}
};
// @desc Analyze tender docs using AI
// @route POST /api/tenders/:id/analyze
export const analyzeTender = async (req, res) => {
try {
const { prompt, promptOnly } = req.body;
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
// --- Generation lock: max 3 full from-scratch runs per project ---
const MAX_GENERATIONS = 3;
if ((tender.generationCount || 0) >= MAX_GENERATIONS) {
return res.status(403).json({
message: `This project has been locked. You have already generated a complete plan and documents ${MAX_GENERATIONS} times. You can still view and download your existing documents.`,
locked: true
});
}
// Prompt-only mode: no files required — user just describes the document they need
if (!promptOnly && tender.inputFiles.length === 0) {
return res.status(400).json({
message: 'Please upload at least one document, or switch to Prompt-Only Draft Mode.'
});
}
// Check Credits - full process costs 10
const user = await User.findById(req.user._id);
if (user.credits < CREDITS.FULL_PROCESS) {
return res.status(403).json({
message: `Insufficient credits. This process costs ${CREDITS.FULL_PROCESS} credits. You have ${user.credits}.`
});
}
// Run AI Analysis (pass promptOnly flag so AI service can adapt)
console.log(`Starting deep analysis for tender ${tender._id} (promptOnly=${!!promptOnly})`);
const analysisResult = await analyzeDocuments(tender.inputFiles, prompt, !!promptOnly);
console.log("Announcement type:", analysisResult.announcement_type);
console.log("Missing docs:", analysisResult.missing_documents);
// Update Database
tender.analysis = {
announcementType: analysisResult.announcement_type,
summary: analysisResult.summary,
requirements: analysisResult.authority_documents,
missingDocuments: analysisResult.missing_documents,
missingDocumentsConfirmed: false,
strategyQuestions: analysisResult.strategy_questions.map(q => ({ question: q, answer: "" })),
isComplete: analysisResult.is_complete
};
tender.draftingPlan = [];
if (prompt) {
tender.userPrompt = prompt;
}
// Increment generation count
tender.generationCount = (tender.generationCount || 0) + 1;
// If there are missing docs, put tender in 'awaiting_documents' status
if (!promptOnly && analysisResult.missing_documents && analysisResult.missing_documents.length > 0) {
tender.status = 'awaiting_documents';
} else {
tender.status = 'analyzing';
}
// Deduct Credits (full 10 credits upfront)
user.credits -= CREDITS.FULL_PROCESS;
await user.save();
await tender.save();
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'ANALYZE_TENDER',
tenderId: tender._id,
tenderTitle: tender.title,
creditsUsed: CREDITS.FULL_PROCESS,
details: {
announcementType: analysisResult.announcement_type,
promptOnly: !!promptOnly,
generationCount: tender.generationCount,
missingDocCount: analysisResult.missing_documents?.length || 0,
hasMissingDocs: (analysisResult.missing_documents?.length || 0) > 0
}
});
res.json(tender);
} catch (error) {
console.error(error);
res.status(500).json({ message: 'AI Analysis Failed', error: error.message });
}
};
// @desc Confirm missing documents are uploaded / skip
// @route POST /api/tenders/:id/confirm-docs
export const confirmMissingDocs = async (req, res) => {
try {
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
tender.analysis.missingDocumentsConfirmed = true;
tender.status = 'analyzing';
await tender.save();
res.json(tender);
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Server Error' });
}
};
// @desc Submit Strategy & Generate Plan
// @route POST /api/tenders/:id/strategy
export const submitStrategy = async (req, res) => {
try {
const { answers } = req.body;
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
if (answers.length !== tender.analysis.strategyQuestions.length) {
return res.status(400).json({ message: 'Please answer all questions' });
}
tender.analysis.strategyQuestions.forEach((q, i) => {
q.answer = answers[i];
});
// Generate detailed plan
console.log("Generating detailed drafting plan...");
const plan = await generateDraftingPlan(
tender.analysis.summary,
tender.analysis.announcementType,
tender.analysis.requirements,
tender.analysis.strategyQuestions,
answers,
tender.inputFiles
);
// Check against existing uploads
console.log("Checking against already uploaded files...");
const uploadedFileNames = tender.inputFiles.map(f => f.originalName);
let satisfiedDocs = [];
if (uploadedFileNames.length > 0) {
satisfiedDocs = await checkExistingDocuments(plan, uploadedFileNames);
}
tender.analysis.existingDocuments = satisfiedDocs;
const finalPlan = plan.filter(item => !satisfiedDocs.includes(item.docName));
// Store plan with full outline data
tender.draftingPlan = finalPlan.map(item => ({
docName: item.docName,
purpose: item.purpose,
outline: item.outline,
status: 'pending'
}));
tender.status = 'planning';
await tender.save();
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'SUBMIT_STRATEGY',
tenderId: tender._id,
tenderTitle: tender.title,
details: {
documentsPlanned: finalPlan.length,
documentsExisting: satisfiedDocs.length
}
});
res.json(tender);
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Failed to save strategy' });
}
};
// @desc Generate the NEXT pending document in the plan
// @route POST /api/tenders/:id/generate-next
export const generateNextDocument = async (req, res) => {
try {
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
// Find the first 'pending' document
const docIndex = tender.draftingPlan.findIndex(d => d.status === 'pending');
if (docIndex === -1) {
tender.status = 'completed';
await tender.save();
return res.json({ message: 'All documents generated', completed: true });
}
const currentDoc = tender.draftingPlan[docIndex];
console.log(`Generating: ${currentDoc.docName}...`);
currentDoc.status = 'generating';
await tender.save();
try {
// Generate Content via AI using the full plan item (includes outline)
const htmlContent = await generateDocumentContent(tender, currentDoc);
const buffer = Buffer.from(htmlContent, 'utf-8');
const fileName = `${tender.title.replace(/\s/g, '_').replaceAll("&", "and")}_${currentDoc.docName.replace(/\s/g, '_')}.html`;
const key = await uploadToR2(buffer, fileName, 'text/html');
tender.draftingPlan[docIndex].status = 'done';
tender.draftingPlan[docIndex].storageKey = key;
// AUTO-MERGE LOGIC for Part documents
const currentName = currentDoc.docName;
const partMatch = currentName.match(/(.*?)[\s-]*Part\s*(\d+)/i);
if (partMatch) {
const baseName = partMatch[1].split(" - ")[0].trim();
const allParts = tender.draftingPlan.filter(d => {
const match = d.docName.match(/(.*?)[\s-]*Part\s*(\d+)/i);
return match && match[1].split(" - ")[0].trim() === baseName;
});
const allDone = allParts.every(p => p.status === 'done');
if (allDone && allParts.length > 1) {
console.log(`All parts for "${baseName}" are done. Merging...`);
allParts.sort((a, b) => {
const numA = parseInt(a.docName.match(/Part\s*(\d+)/i)[1]);
const numB = parseInt(b.docName.match(/Part\s*(\d+)/i)[1]);
return numA - numB;
});
const partContents = [];
for (const part of allParts) {
const stream = await getFileStream(part.storageKey);
const content = await streamToString(stream);
partContents.push(content);
}
const mergedHtml = mergeHtmlParts(partContents, baseName, tender.companyName);
const mergedFileName = `${tender.title.replace(/\s/g, '_')}_${baseName}_FULL.html`;
const mergedKey = await uploadToR2(Buffer.from(mergedHtml), mergedFileName, 'text/html');
const existingIndex = tender.draftingPlan.findIndex(d => d.docName === `${baseName} (Full)`);
const mergedDocEntry = {
docName: `${baseName} (Full)`,
status: 'done',
storageKey: mergedKey
};
if (existingIndex > -1) {
tender.draftingPlan[existingIndex] = mergedDocEntry;
} else {
tender.draftingPlan.push(mergedDocEntry);
}
}
}
await tender.save();
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'GENERATE_DOCUMENT',
tenderId: tender._id,
tenderTitle: tender.title,
details: { docName: currentDoc.docName, docIndex }
});
res.json({
message: `Generated ${currentDoc.docName}`,
completed: false,
docIndex,
docName: currentDoc.docName,
key
});
} catch (genError) {
currentDoc.status = 'pending';
await tender.save();
throw genError;
}
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Generation failed' });
}
};
// Helper to read stream to string
const streamToString = (stream) => {
const chunks = [];
return new Promise((resolve, reject) => {
stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
stream.on('error', (err) => reject(err));
stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
});
};
// @desc Refine a specific document (costs 2 credits)
// @route POST /api/tenders/:id/refine
export const refineDocument = async (req, res) => {
try {
const { docIndex, instruction } = req.body;
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender || !tender.draftingPlan[docIndex]) {
return res.status(404).json({ message: 'Document not found' });
}
// Check credits
const user = await User.findById(req.user._id);
if (user.credits < CREDITS.REFINE_DOCUMENT) {
return res.status(403).json({
message: `Insufficient credits. Refining a document costs ${CREDITS.REFINE_DOCUMENT} credits. You have ${user.credits}.`
});
}
const doc = tender.draftingPlan[docIndex];
console.log(`Fetching current version of ${doc.docName}...`);
const { Body } = await getFileObject(doc.storageKey);
const currentContent = await streamToString(Body);
console.log(`Refining ${doc.docName}...`);
const newContent = await refineDocumentContent(tender, currentContent, instruction);
const buffer = Buffer.from(newContent, 'utf-8');
await uploadToR2(buffer, doc.docName + ".html", 'text/html');
// Deduct credits
user.credits -= CREDITS.REFINE_DOCUMENT;
await user.save();
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'REFINE_DOCUMENT',
tenderId: tender._id,
tenderTitle: tender.title,
creditsUsed: CREDITS.REFINE_DOCUMENT,
details: { docName: doc.docName, instruction: instruction.substring(0, 100) }
});
res.json({
message: 'Document updated successfully',
storageKey: doc.storageKey,
creditsRemaining: user.credits
});
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Refinement failed' });
}
};
// @desc Get Final Submission Instructions
// @route GET /api/tenders/:id/instructions
export const getInstructions = async (req, res) => {
try {
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
if (tender.submissionInstructions) {
return res.json({ instructions: tender.submissionInstructions });
}
const documentsWithLinks = tender.draftingPlan
.filter(doc => doc.status === 'done')
.map((doc, index) => ({
name: doc.docName,
downloadUrl_PDF: `/api/tenders/${tender._id}/download/pdf/${index}`,
downloadUrl_Word: `/api/tenders/${tender._id}/download/docx/${index}`
}));
const instructions = await generateSubmissionInstructions(tender, documentsWithLinks);
tender.submissionInstructions = instructions;
await tender.save();
res.json({ instructions });
} catch (error) {
console.error("Instructions Error:", error);
res.status(500).json({ message: 'Failed to get instructions' });
}
}
// @desc Set / update the company name for a tender project
// @route PATCH /api/tenders/:id/company
export const setCompanyName = async (req, res) => {
try {
const { companyName } = req.body;
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender) return res.status(404).json({ message: 'Tender not found' });
tender.companyName = (companyName || '').trim();
await tender.save();
res.json({ message: 'Company name updated', companyName: tender.companyName });
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Failed to update company name' });
}
};
// @desc Update documentCategory / companyName for a specific file in a tender
// @route PATCH /api/tenders/:id/files
export const updateFileCategory = async (req, res) => {
try {
const { fileIndex, documentCategory, companyName } = req.body;
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender || !tender.inputFiles[fileIndex]) {
return res.status(404).json({ message: 'File not found' });
}
if (documentCategory) {
if (!['call', 'company', 'other'].includes(documentCategory)) {
return res.status(400).json({ message: 'Invalid category. Must be call, company, or other.' });
}
tender.inputFiles[fileIndex].documentCategory = documentCategory;
}
if (companyName !== undefined) {
tender.inputFiles[fileIndex].companyName = (companyName || '').trim();
}
tender.markModified('inputFiles');
await tender.save();
res.json({ message: 'File updated', file: tender.inputFiles[fileIndex] });
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Failed to update file' });
}
};
// @desc Remove a file from a tender
// @route DELETE /api/tenders/:id/files/:fileIndex
export const removeFile = async (req, res) => {
try {
const fileIndex = parseInt(req.params.fileIndex);
const tender = await Tender.findOne({ _id: req.params.id, user: req.user._id });
if (!tender || isNaN(fileIndex) || fileIndex < 0 || fileIndex >= tender.inputFiles.length) {
return res.status(404).json({ message: 'File not found' });
}
// Remove from DB (we do not delete from R2 to keep library functional and safe)
const removedFile = tender.inputFiles.splice(fileIndex, 1)[0];
await ActivityLog.create({
user: req.user._id,
userEmail: req.user.email,
action: 'REMOVE_FILE',
tenderId: tender._id,
tenderTitle: tender.title,
details: { fileName: removedFile.originalName }
});
await tender.save();
res.json({ message: 'File removed successfully', inputFiles: tender.inputFiles });
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Failed to remove file' });
}
};
// @desc Get library of reusable files grouped by company (company docs only)
// @route GET /api/tenders/library
export const getLibraryFiles = async (req, res) => {
try {
const tenders = await Tender.find({ user: req.user._id }).select('inputFiles title companyName');
const allFiles = [];
for (const t of tenders) {
for (const f of t.inputFiles) {
allFiles.push({
...f.toObject(),
tenderTitle: t.title,
tenderId: t._id,
projectCompany: t.companyName || ''
});
}
}
// Group by type for easier library browsing
const callFiles = allFiles.filter(f => f.documentCategory === 'call');
const companyFiles = allFiles.filter(f => f.documentCategory === 'company');
const otherFiles = allFiles.filter(f => !f.documentCategory || f.documentCategory === 'other');
// Deduplicate by storageKey (same file attached to multiple projects)
const seen = new Set();
const dedupe = (arr) => arr.filter(f => {
if (seen.has(f.storageKey)) return false;
seen.add(f.storageKey);
return true;
});
res.json({
companyFiles: dedupe(companyFiles),
callFiles: dedupe(callFiles),
otherFiles: dedupe(otherFiles),
// Flat list for backward compat
all: dedupe([...companyFiles, ...callFiles, ...otherFiles])
});
} catch (error) {
console.error(error);
res.status(500).json({ message: 'Failed to get library' });
}
};
;