webdav.js - master - kalugin66/FileBridge

webdav.js
226 строк8 KB
Калугин Олег Александрович
upload files
24 янв 2026, 15:45
24 янв 2026, 15:4515723b8
const express = require('express');
const router = express.Router();
const { createClient } = require('webdav');
const db = require('./postgresql');
const mail = require('./mail');
const fs = require('fs-extra');
const path = require('path');

// Middleware для проверки админских прав
const requireAdmin = (req, res, next) => {
    if (req.session && req.session.isAdmin) {
        next();
    } else {
        res.status(403).json({ error: 'Admin access required' });
    }
};

// Получение всех WebDAV конфигураций
router.get('/configs', requireAdmin, async (req, res) => {
    try {
        const result = await db.pool.query(
            'SELECT * FROM webdav_configs ORDER BY created_at DESC'
        );
        res.json(result.rows);
    } catch (error) {
        console.error('Error getting WebDAV configs:', error);
        res.status(500).json({ error: 'Server error' });
    }
});

// Создание WebDAV конфигурации
router.post('/configs', requireAdmin, async (req, res) => {
    try {
        const { name, url, username, password, root_path, local_retention_minutes } = req.body;
        
        const result = await db.pool.query(
            `INSERT INTO webdav_configs 
             (name, url, username, password, root_path, local_retention_minutes) 
             VALUES ($1, $2, $3, $4, $5, $6) 
             RETURNING id`,
            [name, url, username, password, root_path, local_retention_minutes || 60]
        );
        
        await mail.sendWebdavConfigNotification('created', name, url);
        
        res.json({ success: true, id: result.rows[0].id });
    } catch (error) {
        console.error('Error creating WebDAV config:', error);
        await mail.sendErrorNotification(`WebDAV error (create config): ${error.message}`);
        res.status(500).json({ error: 'Server error' });
    }
});

// Обновление WebDAV конфигурации
router.put('/configs/:id', requireAdmin, async (req, res) => {
    try {
        const configId = parseInt(req.params.id);
        const { name, url, username, password, root_path, local_retention_minutes, is_active } = req.body;
        
        await db.pool.query(
            `UPDATE webdav_configs 
             SET name = $1, url = $2, username = $3, password = $4, 
                 root_path = $5, local_retention_minutes = $6, is_active = $7
             WHERE id = $8`,
            [name, url, username, password, root_path, local_retention_minutes, is_active, configId]
        );
        
        await mail.sendWebdavConfigNotification('updated', name, url);
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error updating WebDAV config:', error);
        await mail.sendErrorNotification(`WebDAV error (update config): ${error.message}`);
        res.status(500).json({ error: 'Server error' });
    }
});

// Удаление WebDAV конфигурации
router.delete('/configs/:id', requireAdmin, async (req, res) => {
    try {
        const configId = parseInt(req.params.id);
        
        const config = await db.pool.query(
            'SELECT name, url FROM webdav_configs WHERE id = $1',
            [configId]
        );
        
        await db.pool.query('DELETE FROM webdav_configs WHERE id = $1', [configId]);
        
        if (config.rows[0]) {
            await mail.sendWebdavConfigNotification('deleted', config.rows[0].name, config.rows[0].url);
        }
        
        res.json({ success: true });
    } catch (error) {
        console.error('Error deleting WebDAV config:', error);
        await mail.sendErrorNotification(`WebDAV error (delete config): ${error.message}`);
        res.status(500).json({ error: 'Server error' });
    }
});

// Тестирование WebDAV подключения
router.post('/configs/:id/test', requireAdmin, async (req, res) => {
    try {
        const configId = parseInt(req.params.id);
        
        const config = await db.pool.query(
            'SELECT * FROM webdav_configs WHERE id = $1',
            [configId]
        );
        
        if (config.rows.length === 0) {
            return res.status(404).json({ error: 'Config not found' });
        }
        
        const webdavConfig = config.rows[0];
        const client = createClient(webdavConfig.url, {
            username: webdavConfig.username,
            password: webdavConfig.password
        });
        
        // Пытаемся получить информацию о корневой директории
        const directoryItems = await client.getDirectoryContents('/');
        
        // Обновляем статус теста
        await db.pool.query(
            'UPDATE webdav_configs SET last_test = CURRENT_TIMESTAMP, test_status = true WHERE id = $1',
            [configId]
        );
        
        res.json({ 
            success: true, 
            items: directoryItems,
            message: 'Connection successful'
        });
    } catch (error) {
        console.error('Error testing WebDAV:', error);
        
        // Обновляем статус теста как неуспешный
        await db.pool.query(
            'UPDATE webdav_configs SET last_test = CURRENT_TIMESTAMP, test_status = false WHERE id = $1',
            [req.params.id]
        );
        
        res.status(500).json({ 
            error: 'Connection failed', 
            details: error.message 
        });
    }
});

// Синхронизация файлов с WebDAV
router.post('/sync', requireAdmin, async (req, res) => {
    try {
        const activeConfigs = await db.pool.query(
            'SELECT * FROM webdav_configs WHERE is_active = true'
        );
        
        if (activeConfigs.rows.length === 0) {
            return res.json({ message: 'No active WebDAV configurations' });
        }
        
        const config = activeConfigs.rows[0];
        const client = createClient(config.url, {
            username: config.username,
            password: config.password
        });
        
        // Находим файлы для синхронизации
        const filesToSync = await db.pool.query(`
            SELECT * FROM files 
            WHERE storage_location = 'local' 
            AND uploaded_at < NOW() - INTERVAL '${config.local_retention_minutes} minutes'
            AND moved_to_webdav = false
            LIMIT 10
        `);
        
        let syncedCount = 0;
        let failedCount = 0;
        
        for (const file of filesToSync.rows) {
            try {
                // Загружаем файл на WebDAV
                const fileStream = fs.createReadStream(file.full_path);
                const remotePath = path.join(
                    config.root_path || '',
                    file.service_name,
                    // file.date,
                    // file.hour.toString(),
                    file.date instanceof Date ? file.date.toISOString().split('T')[0] : String(file.date || ''),
                    String(file.hour || '0'),
                    `${file.file_number}${path.extname(file.filename)}`
                );
                
                await client.putFileContents(remotePath, fileStream);
                
                // Обновляем запись в базе
                await db.updateFileStorageLocation(file.id, 'webdav');
                
                // Удаляем локальный файл
                await fs.unlink(file.full_path);
                
                syncedCount++;
                
            } catch (error) {
                console.error(`Error syncing file ${file.id}:`, error);
                failedCount++;
            }
        }
        
        await mail.sendWebdavSyncNotification(syncedCount, failedCount);
        
        res.json({
            success: true,
            synced: syncedCount,
            failed: failedCount,
            message: `Synced ${syncedCount} files to WebDAV`
        });
    } catch (error) {
        console.error('Sync error:', error);
        await mail.sendErrorNotification(`WebDAV sync error: ${error.message}`);
        res.status(500).json({ error: 'Sync failed' });
    }
});

module.exports = router;