Spaces:
Paused
Paused
Download src/controllers/tenderController.js from ismizo/tenderizer: direct link, hf CLI and curl.
- Browser
- Download file 27.9 kB
-
https://huggingface.co/spaces/ismizo/tenderizer/resolve/main/src/controllers/tenderController.js
- Command line
-
hf download hf://spaces/ismizo/tenderizer/src/controllers/tenderController.js
-
curl -L -o tenderController.js https://huggingface.co/spaces/ismizo/tenderizer/resolve/main/src/controllers/tenderController.js
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' }); | |
| } | |
| }; | |
| ; |