server.js - master - kalugin66/FileBridge

server.js
165 строк5 KB
kalugin66
postgresql
25 янв 2026, 10:29
25 янв 2026, 10:2962ba585
const express = require('express');
const session = require('express-session');
const bodyParser = require('body-parser');
const path = require('path');
const dotenv = require('dotenv');
const crypto = require('crypto');
const fs = require('fs').promises;

dotenv.config();

const app = express();
const port = process.env.PORT || 3000;

// Middleware
app.use(bodyParser.json({ limit: process.env.UPLOAD_MAX_SIZE }));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));

// Сессии
app.use(session({
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: process.env.NODE_ENV === 'production',
        maxAge: parseInt(process.env.SESSION_TIMEOUT) || 86400000
    }
}));

// Middleware для проверки авторизации
const requireAuth = (req, res, next) => {
    if (req.session.user) {
        next();
    } else {
        res.redirect('/login.html');
    }
};

// Middleware для проверки токена API
const checkApiToken = (req, res, next) => {
    const token = req.headers['x-api-token'] || req.query.token;
    const staticToken = process.env.STATIC_TOKEN;
    
    // Получаем динамический токен из базы
    const getDynamicToken = async () => {
        const db = require('./postgresql.js');
        try {
            const result = await db.query(
                'SELECT value FROM system WHERE key = $1',
                ['token']
            );
            return result.rows[0]?.value;
        } catch (err) {
            console.error('Error getting dynamic token:', err);
            return null;
        }
    };
    
    (async () => {
        const dynamicToken = await getDynamicToken();
        
        if (token === staticToken || token === dynamicToken) {
            next();
        } else {
            console.log('------------------------- token -------------------------');
            console.log('Invalid token provided:', token);
            console.log('Expected static token:', staticToken);
            console.log('Expected dynamic token:', dynamicToken);
            res.status(401).json({ error: 'Invalid API token' });
        }
    })();
};

// Импорт модулей
const db = require('./postgresql.js');
const restapi = require('./restapi.js')(app, checkApiToken);
const auth = require('./login.js')(app);
const mail = require('./mail.js');

// Генерация динамического токена при запуске
const generateDynamicToken = async () => {
    const dynamicToken = crypto.randomBytes(32).toString('hex');
    
    try {
        // Сохраняем динамический токен в базу
        await db.query(`
            INSERT INTO system (key, value) 
            VALUES ('token', $1)
            ON CONFLICT (key) DO UPDATE SET value = $1
        `, [dynamicToken]);
        console.log('Dynamic token generated and saved to database');
        return dynamicToken;
    } catch (err) {
        console.error('Error saving dynamic token:', err);
        return dynamicToken;
    }
};

// Инициализация базы данных при запуске
(async () => {
    try {
        await db.init();
        const dynamicToken = await generateDynamicToken();
        console.log('Database initialized successfully');
        console.log(`Static token from .env: ${process.env.STATIC_TOKEN}`);
        console.log(`Dynamic token (from DB): ${dynamicToken}`);
    } catch (err) {
        console.error('Database initialization failed:', err);
    }
})();

// Защищенные маршруты
app.get('/', requireAuth, (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

app.get('/admin', requireAuth, (req, res) => {
    if (req.session.user.is_admin) {
        res.sendFile(path.join(__dirname, 'public', 'admin.html'));
    } else {
        res.status(403).send('Access denied');
    }
});

app.get('/token', requireAuth, (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'token.html'));
});

// API для получения динамического токена
app.get('/api/token', requireAuth, async (req, res) => {
    try {
        const result = await db.query(
            'SELECT value FROM system WHERE key = $1',
            ['token']
        );
        if (result.rows.length > 0) {
            res.json({ token: result.rows[0].value });
        } else {
            // Если токена нет в базе, генерируем новый
            const newToken = await generateDynamicToken();
            res.json({ token: newToken });
        }
    } catch (err) {
        console.error('Error getting token:', err);
        res.status(500).json({ error: err.message });
    }
});

// API для проверки авторизации
app.get('/api/check-auth', (req, res) => {
    if (req.session.user) {
        res.json({ 
            authenticated: true, 
            user: req.session.user 
        });
    } else {
        res.json({ authenticated: false });
    }
});

// Запуск сервера
app.listen(port, () => {
    console.log(`Server running on port ${port}`);
    console.log(`App URL: ${process.env.APP_URL || `http://localhost:${port}`}`);
});