418 lines
12 KiB
JavaScript
418 lines
12 KiB
JavaScript
const express = require('express');
|
||
const router = express.Router();
|
||
const { verifyToken } = require('../middleware/auth');
|
||
const Request = require('../models/Request');
|
||
const BuyProduct = require('../models/BuyProduct');
|
||
const fs = require('fs');
|
||
const multer = require('multer');
|
||
|
||
// Функция для логирования с проверкой DEV переменной
|
||
const log = (message, data = '') => {
|
||
if (process.env.DEV === 'true') {
|
||
if (data) {
|
||
console.log(message, data);
|
||
} else {
|
||
console.log(message);
|
||
}
|
||
}
|
||
};
|
||
|
||
const REQUESTS_UPLOAD_ROOT = 'server/remote-assets/uploads/requests';
|
||
|
||
const ensureDirectory = (dirPath) => {
|
||
if (!fs.existsSync(dirPath)) {
|
||
fs.mkdirSync(dirPath, { recursive: true });
|
||
}
|
||
};
|
||
|
||
ensureDirectory(REQUESTS_UPLOAD_ROOT);
|
||
|
||
const MAX_REQUEST_FILE_SIZE = 20 * 1024 * 1024; // 20MB
|
||
const ALLOWED_REQUEST_MIME_TYPES = new Set([
|
||
'application/pdf',
|
||
'application/msword',
|
||
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
'application/vnd.ms-excel',
|
||
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
'text/csv',
|
||
]);
|
||
|
||
const getExtension = (filename) => {
|
||
const lastDot = filename.lastIndexOf('.');
|
||
return lastDot > 0 ? filename.slice(lastDot) : '';
|
||
};
|
||
|
||
const getBasename = (filename) => {
|
||
const lastDot = filename.lastIndexOf('.');
|
||
const name = lastDot > 0 ? filename.slice(0, lastDot) : filename;
|
||
const lastSlash = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\'));
|
||
return lastSlash >= 0 ? name.slice(lastSlash + 1) : name;
|
||
};
|
||
|
||
const storage = multer.diskStorage({
|
||
destination: (req, file, cb) => {
|
||
const subfolder = req.requestUploadSubfolder || '';
|
||
const destinationDir = subfolder ? `${REQUESTS_UPLOAD_ROOT}/${subfolder}` : REQUESTS_UPLOAD_ROOT;
|
||
ensureDirectory(destinationDir);
|
||
cb(null, destinationDir);
|
||
},
|
||
filename: (req, file, cb) => {
|
||
const extension = getExtension(file.originalname);
|
||
const baseName = getBasename(file.originalname)
|
||
.replace(/[^a-zA-Z0-9-_]+/g, '_')
|
||
.toLowerCase();
|
||
cb(null, `${Date.now()}_${baseName}${extension}`);
|
||
},
|
||
});
|
||
|
||
const upload = multer({
|
||
storage,
|
||
limits: {
|
||
fileSize: MAX_REQUEST_FILE_SIZE,
|
||
},
|
||
fileFilter: (req, file, cb) => {
|
||
if (ALLOWED_REQUEST_MIME_TYPES.has(file.mimetype)) {
|
||
cb(null, true);
|
||
return;
|
||
}
|
||
|
||
if (!req.invalidFiles) {
|
||
req.invalidFiles = [];
|
||
}
|
||
req.invalidFiles.push(file.originalname);
|
||
cb(null, false);
|
||
},
|
||
});
|
||
|
||
const handleFilesUpload = (fieldName, subfolderResolver, maxCount = 10) => (req, res, next) => {
|
||
req.invalidFiles = [];
|
||
req.requestUploadSubfolder = subfolderResolver(req);
|
||
|
||
upload.array(fieldName, maxCount)(req, res, (err) => {
|
||
if (err) {
|
||
console.error('[Requests] Multer error:', err.message);
|
||
if (err.code === 'LIMIT_FILE_SIZE') {
|
||
return res.status(400).json({ error: 'File is too large. Maximum size is 20MB.' });
|
||
}
|
||
return res.status(400).json({ error: err.message });
|
||
}
|
||
next();
|
||
});
|
||
};
|
||
|
||
const cleanupUploadedFiles = async (req) => {
|
||
if (!Array.isArray(req.files) || req.files.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const subfolder = req.requestUploadSubfolder || '';
|
||
const removalTasks = req.files.map((file) => {
|
||
const filePath = subfolder ? `${REQUESTS_UPLOAD_ROOT}/${subfolder}/${file.filename}` : `${REQUESTS_UPLOAD_ROOT}/${file.filename}`;
|
||
return fs.promises.unlink(filePath).catch((error) => {
|
||
if (error.code !== 'ENOENT') {
|
||
console.error('[Requests] Failed to cleanup uploaded file:', error.message);
|
||
}
|
||
});
|
||
});
|
||
|
||
await Promise.all(removalTasks);
|
||
};
|
||
|
||
const mapFilesToMetadata = (req) => {
|
||
if (!Array.isArray(req.files) || req.files.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const subfolder = req.requestUploadSubfolder || '';
|
||
return req.files.map((file) => {
|
||
const relativePath = subfolder ? `requests/${subfolder}/${file.filename}` : `requests/${file.filename}`;
|
||
return {
|
||
id: `file-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
|
||
name: file.originalname,
|
||
url: `/uploads/${relativePath}`,
|
||
type: file.mimetype,
|
||
size: file.size,
|
||
uploadedAt: new Date(),
|
||
storagePath: relativePath,
|
||
};
|
||
});
|
||
};
|
||
|
||
const normalizeToArray = (value) => {
|
||
if (!value) {
|
||
return [];
|
||
}
|
||
if (Array.isArray(value)) {
|
||
return value;
|
||
}
|
||
|
||
try {
|
||
const parsed = JSON.parse(value);
|
||
if (Array.isArray(parsed)) {
|
||
return parsed;
|
||
}
|
||
} catch (error) {
|
||
// ignore JSON parse errors
|
||
}
|
||
|
||
return String(value)
|
||
.split(',')
|
||
.map((item) => item.trim())
|
||
.filter(Boolean);
|
||
};
|
||
|
||
const removeStoredFiles = async (files = []) => {
|
||
if (!files || files.length === 0) {
|
||
return;
|
||
}
|
||
|
||
const tasks = files
|
||
.filter((file) => file && file.storagePath)
|
||
.map((file) => {
|
||
const absolutePath = `server/remote-assets/uploads/${file.storagePath}`;
|
||
return fs.promises.unlink(absolutePath).catch((error) => {
|
||
if (error.code !== 'ENOENT') {
|
||
console.error('[Requests] Failed to remove stored file:', error.message);
|
||
}
|
||
});
|
||
});
|
||
|
||
await Promise.all(tasks);
|
||
};
|
||
|
||
// GET /requests/sent - получить отправленные запросы
|
||
router.get('/sent', verifyToken, async (req, res) => {
|
||
try {
|
||
const companyId = req.companyId;
|
||
|
||
if (!companyId) {
|
||
return res.status(400).json({ error: 'Company ID is required' });
|
||
}
|
||
|
||
const requests = await Request.find({ senderCompanyId: companyId })
|
||
.sort({ createdAt: -1 })
|
||
.exec();
|
||
|
||
log('[Requests] Returned', requests.length, 'sent requests for company', companyId);
|
||
|
||
res.json(requests);
|
||
} catch (error) {
|
||
console.error('[Requests] Error fetching sent requests:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// GET /requests/received - получить полученные запросы
|
||
router.get('/received', verifyToken, async (req, res) => {
|
||
try {
|
||
const companyId = req.companyId;
|
||
|
||
if (!companyId) {
|
||
return res.status(400).json({ error: 'Company ID is required' });
|
||
}
|
||
|
||
const requests = await Request.find({ recipientCompanyId: companyId })
|
||
.sort({ createdAt: -1 })
|
||
.exec();
|
||
|
||
log('[Requests] Returned', requests.length, 'received requests for company', companyId);
|
||
|
||
res.json(requests);
|
||
} catch (error) {
|
||
console.error('[Requests] Error fetching received requests:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// POST /requests - создать запрос
|
||
router.post(
|
||
'/',
|
||
verifyToken,
|
||
handleFilesUpload('files', (req) => `sent/${(req.companyId || 'unknown').toString()}`, 10),
|
||
async (req, res) => {
|
||
try {
|
||
const senderCompanyId = req.companyId;
|
||
const recipients = normalizeToArray(req.body.recipientCompanyIds);
|
||
const text = (req.body.text || '').trim();
|
||
const productId = req.body.productId ? String(req.body.productId) : null;
|
||
let subject = (req.body.subject || '').trim();
|
||
|
||
if (req.invalidFiles && req.invalidFiles.length > 0) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({
|
||
error: 'Unsupported file type. Allowed formats: PDF, DOC, DOCX, XLS, XLSX, CSV.',
|
||
details: req.invalidFiles,
|
||
});
|
||
}
|
||
|
||
if (!text) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({ error: 'Request text is required' });
|
||
}
|
||
|
||
if (!recipients.length) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({ error: 'At least one recipient is required' });
|
||
}
|
||
|
||
if (!subject && productId) {
|
||
try {
|
||
const product = await BuyProduct.findById(productId);
|
||
if (product) {
|
||
subject = product.name;
|
||
}
|
||
} catch (lookupError) {
|
||
console.error('[Requests] Failed to lookup product for subject:', lookupError.message);
|
||
}
|
||
}
|
||
|
||
if (!subject) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({ error: 'Subject is required' });
|
||
}
|
||
|
||
const uploadedFiles = mapFilesToMetadata(req);
|
||
|
||
const results = [];
|
||
for (const recipientCompanyId of recipients) {
|
||
try {
|
||
const request = new Request({
|
||
senderCompanyId,
|
||
recipientCompanyId,
|
||
text,
|
||
productId,
|
||
subject,
|
||
files: uploadedFiles,
|
||
responseFiles: [],
|
||
status: 'pending',
|
||
});
|
||
|
||
await request.save();
|
||
results.push({
|
||
companyId: recipientCompanyId,
|
||
success: true,
|
||
message: 'Request sent successfully',
|
||
});
|
||
|
||
log('[Requests] Request sent to company:', recipientCompanyId);
|
||
} catch (err) {
|
||
console.error('[Requests] Error storing request for company:', recipientCompanyId, err.message);
|
||
results.push({
|
||
companyId: recipientCompanyId,
|
||
success: false,
|
||
message: err.message,
|
||
});
|
||
}
|
||
}
|
||
|
||
const createdAt = new Date();
|
||
|
||
res.status(201).json({
|
||
id: 'bulk-' + Date.now(),
|
||
text,
|
||
subject,
|
||
productId,
|
||
files: uploadedFiles,
|
||
result: results,
|
||
createdAt,
|
||
});
|
||
} catch (error) {
|
||
console.error('[Requests] Error creating request:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
}
|
||
);
|
||
|
||
// PUT /requests/:id - ответить на запрос
|
||
router.put(
|
||
'/:id',
|
||
verifyToken,
|
||
handleFilesUpload('responseFiles', (req) => `responses/${req.params.id || 'unknown'}`, 5),
|
||
async (req, res) => {
|
||
try {
|
||
const { id } = req.params;
|
||
const responseText = (req.body.response || '').trim();
|
||
const statusRaw = (req.body.status || 'accepted').toLowerCase();
|
||
const status = statusRaw === 'rejected' ? 'rejected' : 'accepted';
|
||
|
||
if (req.invalidFiles && req.invalidFiles.length > 0) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({
|
||
error: 'Unsupported file type. Allowed formats: PDF, DOC, DOCX, XLS, XLSX, CSV.',
|
||
details: req.invalidFiles,
|
||
});
|
||
}
|
||
|
||
if (!responseText) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(400).json({ error: 'Response text is required' });
|
||
}
|
||
|
||
const request = await Request.findById(id);
|
||
|
||
if (!request) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(404).json({ error: 'Request not found' });
|
||
}
|
||
|
||
if (request.recipientCompanyId !== req.companyId) {
|
||
await cleanupUploadedFiles(req);
|
||
return res.status(403).json({ error: 'Not authorized' });
|
||
}
|
||
|
||
const uploadedResponseFiles = mapFilesToMetadata(req);
|
||
|
||
if (uploadedResponseFiles.length > 0) {
|
||
await removeStoredFiles(request.responseFiles || []);
|
||
request.responseFiles = uploadedResponseFiles;
|
||
}
|
||
|
||
request.response = responseText;
|
||
request.status = status;
|
||
request.respondedAt = new Date();
|
||
request.updatedAt = new Date();
|
||
|
||
await request.save();
|
||
|
||
log('[Requests] Request responded:', id);
|
||
|
||
res.json(request);
|
||
} catch (error) {
|
||
console.error('[Requests] Error responding to request:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
}
|
||
);
|
||
|
||
// DELETE /requests/:id - удалить запрос
|
||
router.delete('/:id', verifyToken, async (req, res) => {
|
||
try {
|
||
const { id } = req.params;
|
||
|
||
const request = await Request.findById(id);
|
||
|
||
if (!request) {
|
||
return res.status(404).json({ error: 'Request not found' });
|
||
}
|
||
|
||
// Может удалить отправитель или получатель
|
||
if (request.senderCompanyId !== req.companyId && request.recipientCompanyId !== req.companyId) {
|
||
return res.status(403).json({ error: 'Not authorized' });
|
||
}
|
||
|
||
await removeStoredFiles(request.files || []);
|
||
await removeStoredFiles(request.responseFiles || []);
|
||
|
||
await Request.findByIdAndDelete(id);
|
||
|
||
log('[Requests] Request deleted:', id);
|
||
|
||
res.json({ message: 'Request deleted successfully' });
|
||
} catch (error) {
|
||
console.error('[Requests] Error deleting request:', error.message);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
module.exports = router;
|