Site/server/controllers/agrobaseController.js

const express = require('express');
const router = express.Router();
const formidable = require('formidable');
const unzipper = require('unzipper');
const fs = require('fs');
const path = require('path');

// Defina o caminho do arquivo .vsf
const vsfFilePath = path.join('/var/www/html/agrobase/downloads/version_files.vsf');

var routes = function () {

    router.get('/getVsfData', (req, res) => {
        fs.readFile(vsfFilePath, 'utf8', (err, data) => {
            if (err) {
                console.error("Erro ao ler o arquivo .vsf:", err);
                return res.status(500).json({ message: "Erro ao ler o arquivo .vsf" });
            }
    
            // Tenta converter o conteúdo em JSON
            try {
                const jsonData = JSON.parse(data);
                res.json(jsonData);
            } catch (parseError) {
                console.error("Erro ao analisar o arquivo .vsf:", parseError);
                res.status(500).json({ message: "Erro ao analisar o conteúdo do arquivo .vsf" });
            }
        });
    });

    router.post('/uploadTrainFiles', (req, res) => {
        let form = new formidable.IncomingForm();
        form.maxFileSize = 600 * 1024 * 1024; // Limite de tamanho do arquivo
        form.parse(req, async function (err, fields, files) {
            if (err) {
                console.error("Erro ao processar o arquivo:", err);
                return res.status(500).send("Erro no processamento");
            }

            const nomeOperacao = fields.operacaoId;
            const arquivoZipPath = files['imagens.zip'].path;
            const dirDestino = '/var/www/html/agrobase/trainfiles/';

            try {
                // Certifique-se de que o diretório de destino existe
                if (!fs.existsSync(dirDestino)) {
                    fs.mkdirSync(dirDestino, { recursive: true });
                }

                // Caminho completo do diretório para esta operação específica
                const dirOperacao = path.join(dirDestino, nomeOperacao);

                // Certifique-se de que o diretório da operação existe
                if (!fs.existsSync(dirOperacao)) {
                    fs.mkdirSync(dirOperacao, { recursive: true });
                }

                // Abrir o arquivo zip e extrair as imagens com as subpastas
                fs.createReadStream(arquivoZipPath)
                    .pipe(unzipper.Parse())
                    .on('entry', async function (entry) {
                        const fileName = entry.path;
                        const type = entry.type; // 'Directory' ou 'File'

                        if (type === 'File' && fileName.endsWith('.jpg')) {
                            // Caminho de destino da imagem extraída (mantém a subpasta, se houver)
                            const caminhoImagem = path.join(dirOperacao, fileName);
                            const dirImagem = path.dirname(caminhoImagem);

                            // Certifique-se de que a subpasta da imagem existe
                            if (!fs.existsSync(dirImagem)) {
                                fs.mkdirSync(dirImagem, { recursive: true });
                            }

                            // Salvar a imagem no diretório correto
                            entry.pipe(fs.createWriteStream(caminhoImagem));
                        } else {
                            entry.autodrain(); // Ignorar diretórios ou arquivos não suportados
                        }
                    })
                    .on('close', () => {
                        console.log("Arquivo descompactado com sucesso e imagens sincronizadas.");
                        res.send(true);
                    });
            } catch (error) {
                console.error("Erro ao descompactar o arquivo:", error);
                res.status(500).send("Erro no processamento do arquivo ZIP");
            }
        });
    });

    router.post('/uploadVersionFiles', (req, res) => {
        let form = new formidable.IncomingForm();
        form.maxFileSize = 600 * 1024 * 1024; // Limite de tamanho do arquivo
    
        form.parse(req, async function (err, fields, files) {
            if (err) {
                console.error("Erro ao processar o arquivo:", err);
                return res.status(500).send("Erro no processamento");
            }
    
            const file = files.file;
            const fileName = fields.fileName; // Nome do arquivo formatado
            const destino = `/var/www/html/agrobase/downloads/${fileName}`;
            
            fs.copyFile(file.path, destino, (err) => {
                if (err) {
                    console.error("Erro ao salvar o arquivo:", err);
                    return res.status(500).send("Erro ao salvar o arquivo");
                }
                res.status(200).send({ filePath: destino });
            });
        });
    });

    router.post('/deleteVersionFile', (req, res) => {
        const { filePath } = req.body;
    
        if (!filePath) {
            return res.status(400).send("Caminho do arquivo não fornecido.");
        }
    
        const downloadsDir = '/var/www/html/agrobase/downloads';
        const fullPath = path.join(downloadsDir, path.basename(filePath));
    
        fs.access(fullPath, fs.constants.F_OK, (err) => {
            if (err) {
                console.error("Arquivo não encontrado:", err);
                return res.status(404).send("Arquivo não encontrado.");
            }
    
            fs.unlink(fullPath, (err) => {
                if (err) {
                    console.error("Erro ao excluir o arquivo:", err);
                    return res.status(500).send("Erro ao excluir o arquivo.");
                }
    
                res.status(200).send({ message: "Arquivo excluído com sucesso." });
            });
        });
    });

    router.post('/updateVsfFile', (req, res) => {
        const jsonData = req.body.data; // Dados JSON do Angular
    
        fs.writeFile(vsfFilePath, jsonData, 'utf8', (err) => {
            if (err) {
                console.error("Erro ao atualizar o arquivo .vsf:", err);
                return res.status(500).send("Erro ao salvar o arquivo .vsf");
            }
            res.status(200).send("Arquivo .vsf atualizado com sucesso");
        });
    });

    router.post('/login', function (req, res) {
        let usuario = req.body.usuario;
        let senha = req.body.senha;
        const sqlQuery = `SELECT
            nome
        FROM usuarios
        WHERE usuario = '${usuario}' AND senha = '${senha}';`;
        ExecuteQueryAgro(sqlQuery, req, res);
    });

    return router;
}

module.exports = routes;