smanab/App-Jurnal/api/routes/settings.js

import express from 'express';
import { pool } from '../config/database.js';
import { uploadLogo, uploadKop } from '../middleware/upload.js';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const router = express.Router();

// Helper function to save base64 image to public folder
const saveBase64ToFile = async (base64Data, type) => {
    if (!base64Data || base64Data.startsWith('/images/')) {
        return base64Data;
    }

    try {
        if (!base64Data.startsWith('data:')) {
            return base64Data;
        }

        const matches = base64Data.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
        if (!matches || matches.length !== 3) {
            return base64Data;
        }

        const mimeType = matches[1];
        const data = matches[2];
        const buffer = Buffer.from(data, 'base64');

        let ext = '.png';
        if (mimeType.includes('jpeg') || mimeType.includes('jpg')) ext = '.jpg';
        else if (mimeType.includes('gif')) ext = '.gif';
        else if (mimeType.includes('webp')) ext = '.webp';

        const filename = `${type}_${Date.now()}${ext}`;
        const dir = path.join(__dirname, `../../public/images/${type}`);

        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }

        const filepath = path.join(dir, filename);
        fs.writeFileSync(filepath, buffer);

        return `/images/${type}/${filename}`;
    } catch (error) {
        console.error(`Error saving ${type} image:`, error);
        return base64Data;
    }
};

// POST /api/settings - Save school settings
router.post('/', async (req, res) => {
    const connection = await pool.getConnection();

    try {
        await connection.beginTransaction();

        const { action, payload } = req.body;
        const data = payload || req.body;

        let logoUrl = data.LogoUrl || data.logoUrl || '';
        if (logoUrl && logoUrl.startsWith('data:')) {
            logoUrl = await saveBase64ToFile(logoUrl, 'logo');
        }

        let kopUrl = data.KopUrl || data.kopUrl || '';
        if (kopUrl && kopUrl.startsWith('data:')) {
            kopUrl = await saveBase64ToFile(kopUrl, 'kop');
        }

        const settings = {
            'semester': data.Semester || data.semester || 'Ganjil',
            'academic_year': data.TahunPelajaran || data.academicYear || '',
            'headmaster_name': data.NamaKepalaSekolah || data.headmasterName || '',
            'headmaster_nip': data.NipKepalaSekolah || data.headmasterNip || '',
            'logo_url': logoUrl,
            'kop_url': kopUrl
        };

        for (const [key, value] of Object.entries(settings)) {
            await connection.query(`
                INSERT INTO school_settings (setting_key, setting_value)
                VALUES (?, ?)
                ON DUPLICATE KEY UPDATE setting_value = VALUES(setting_value)
            `, [key, value]);
        }

        await connection.commit();

        res.json({ status: 'success', message: 'Settings saved successfully' });
    } catch (error) {
        await connection.rollback();
        console.error('Error saving settings:', error);
        res.status(500).json({ status: 'error', message: error.message });
    } finally {
        connection.release();
    }
});

// POST /api/settings/upload-logo - Upload logo file
router.post('/upload-logo', uploadLogo.single('logo'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ status: 'error', message: 'No file uploaded' });
        }

        const logoUrl = `/images/logo/${req.file.filename}`;

        await pool.query(`
            INSERT INTO school_settings (setting_key, setting_value)
            VALUES ('logo_url', ?)
            ON DUPLICATE KEY UPDATE setting_value = VALUES(setting_value)
        `, [logoUrl]);

        res.json({
            status: 'success',
            message: 'Logo uploaded successfully',
            url: logoUrl
        });
    } catch (error) {
        console.error('Error uploading logo:', error);
        res.status(500).json({ status: 'error', message: error.message });
    }
});

// POST /api/settings/upload-kop - Upload kop file
router.post('/upload-kop', uploadKop.single('kop'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ status: 'error', message: 'No file uploaded' });
        }

        const kopUrl = `/images/kop/${req.file.filename}`;

        await pool.query(`
            INSERT INTO school_settings (setting_key, setting_value)
            VALUES ('kop_url', ?)
            ON DUPLICATE KEY UPDATE setting_value = VALUES(setting_value)
        `, [kopUrl]);

        res.json({
            status: 'success',
            message: 'Kop uploaded successfully',
            url: kopUrl
        });
    } catch (error) {
        console.error('Error uploading kop:', error);
        res.status(500).json({ status: 'error', message: error.message });
    }
});

export default router;