Aula 2: Módulos e Sistema de Arquivos

const Product = require('../models/Product');
const FileHelper = require('../utils/FileHelper');
const path = require('path');

class ProductController {
    constructor() {
        this.dataPath = path.join(__dirname, '..', 'data', 'products.json');
        this.fileHelper = new FileHelper();
    }

    // Criar um novo produto
    async createProduct(productData) {
        try {
            // Carregar produtos existentes
            const products = await this.getAllProducts();
            
            // Criar novo produto
            const newProduct = new Product(
                productData.name,
                productData.price,
                productData.category,
                productData.description
            );
            
            // Adicionar à lista
            products.push(newProduct);
            
            // Salvar no arquivo
            await this.fileHelper.writeJSON(this.dataPath, products);
            
            console.log(`✅ Produto "${newProduct.name}" criado com sucesso!`);
            return newProduct;
        } catch (error) {
            console.error('❌ Erro ao criar produto:', error.message);
            throw error;
        }
    }

    // Listar todos os produtos
    async getAllProducts() {
        try {
            const products = await this.fileHelper.readJSON(this.dataPath);
            return products || [];
        } catch (error) {
            console.log('📁 Arquivo de produtos não encontrado, criando novo...');
            return [];
        }
    }

    // Buscar produto por ID
    async getProductById(id) {
        try {
            const products = await this.getAllProducts();
            const product = products.find(p => p.id === id);
            
            if (!product) {
                throw new Error(`Produto com ID ${id} não encontrado`);
            }
            
            return product;
        } catch (error) {
            console.error('❌ Erro ao buscar produto:', error.message);
            throw error;
        }
    }

    // Atualizar produto
    async updateProduct(id, updateData) {
        try {
            const products = await this.getAllProducts();
            const productIndex = products.findIndex(p => p.id === id);
            
            if (productIndex === -1) {
                throw new Error(`Produto com ID ${id} não encontrado`);
            }
            
            // Atualizar dados
            products[productIndex] = { ...products[productIndex], ...updateData };
            
            // Salvar no arquivo
            await this.fileHelper.writeJSON(this.dataPath, products);
            
            console.log(`✅ Produto "${products[productIndex].name}" atualizado!`);
            return products[productIndex];
        } catch (error) {
            console.error('❌ Erro ao atualizar produto:', error.message);
            throw error;
        }
    }

    // Deletar produto
    async deleteProduct(id) {
        try {
            const products = await this.getAllProducts();
            const productIndex = products.findIndex(p => p.id === id);
            
            if (productIndex === -1) {
                throw new Error(`Produto com ID ${id} não encontrado`);
            }
            
            const deletedProduct = products.splice(productIndex, 1)[0];
            
            // Salvar no arquivo
            await this.fileHelper.writeJSON(this.dataPath, products);
            
            console.log(`🗑️ Produto "${deletedProduct.name}" deletado!`);
            return deletedProduct;
        } catch (error) {
            console.error('❌ Erro ao deletar produto:', error.message);
            throw error;
        }
    }

    // Buscar produtos por categoria
    async getProductsByCategory(categoryName) {
        try {
            const products = await this.getAllProducts();
            return products.filter(p => p.category.toLowerCase() === categoryName.toLowerCase());
        } catch (error) {
            console.error('❌ Erro ao buscar produtos por categoria:', error.message);
            throw error;
        }
    }
}

module.exports = ProductController;

const Category = require('../models/Category');
const FileHelper = require('../utils/FileHelper');
const path = require('path');

class CategoryController {
    constructor() {
        this.dataPath = path.join(__dirname, '..', 'data', 'categories.json');
        this.fileHelper = new FileHelper();
    }

    // Criar nova categoria
    async createCategory(categoryData) {
        try {
            const categories = await this.getAllCategories();
            
            // Verificar se categoria já existe
            const existingCategory = categories.find(c => 
                c.name.toLowerCase() === categoryData.name.toLowerCase()
            );
            
            if (existingCategory) {
                throw new Error(`Categoria "${categoryData.name}" já existe!`);
            }
            
            const newCategory = new Category(
                categoryData.name,
                categoryData.description
            );
            
            categories.push(newCategory);
            await this.fileHelper.writeJSON(this.dataPath, categories);
            
            console.log(`✅ Categoria "${newCategory.name}" criada com sucesso!`);
            return newCategory;
        } catch (error) {
            console.error('❌ Erro ao criar categoria:', error.message);
            throw error;
        }
    }

    // Listar todas as categorias
    async getAllCategories() {
        try {
            const categories = await this.fileHelper.readJSON(this.dataPath);
            return categories || [];
        } catch (error) {
            console.log('📁 Arquivo de categorias não encontrado, criando novo...');
            return [];
        }
    }

    // Buscar categoria por ID
    async getCategoryById(id) {
        try {
            const categories = await this.getAllCategories();
            const category = categories.find(c => c.id === id);
            
            if (!category) {
                throw new Error(`Categoria com ID ${id} não encontrada`);
            }
            
            return category;
        } catch (error) {
            console.error('❌ Erro ao buscar categoria:', error.message);
            throw error;
        }
    }

    // Deletar categoria
    async deleteCategory(id) {
        try {
            const categories = await this.getAllCategories();
            const categoryIndex = categories.findIndex(c => c.id === id);
            
            if (categoryIndex === -1) {
                throw new Error(`Categoria com ID ${id} não encontrada`);
            }
            
            const deletedCategory = categories.splice(categoryIndex, 1)[0];
            await this.fileHelper.writeJSON(this.dataPath, categories);
            
            console.log(`🗑️ Categoria "${deletedCategory.name}" deletada!`);
            return deletedCategory;
        } catch (error) {
            console.error('❌ Erro ao deletar categoria:', error.message);
            throw error;
        }
    }
}

module.exports = CategoryController;

const fs = require('fs').promises;
const path = require('path');

class Logger {
    constructor() {
        this.logPath = path.join(__dirname, '..', 'logs', 'system.log');
        this.ensureLogDirectory();
    }

    // Garantir que o diretório de logs existe
    async ensureLogDirectory() {
        try {
            const logDir = path.dirname(this.logPath);
            await fs.mkdir(logDir, { recursive: true });
        } catch (error) {
            console.error('Erro ao criar diretório de logs:', error.message);
        }
    }

    // Registrar log
    async log(level, message, data = null) {
        try {
            const timestamp = new Date().toISOString();
            const logEntry = {
                timestamp,
                level: level.toUpperCase(),
                message,
                data
            };
            
            const logLine = JSON.stringify(logEntry) + '\n';
            await fs.appendFile(this.logPath, logLine);
            
            // Também exibir no console
            const emoji = this.getEmojiForLevel(level);
            console.log(`${emoji} [${timestamp}] ${level.toUpperCase()}: ${message}`);
            
        } catch (error) {
            console.error('Erro ao escrever log:', error.message);
        }
    }

    // Obter emoji para o nível do log
    getEmojiForLevel(level) {
        const emojis = {
            info: 'ℹ️',
            success: '✅',
            warning: '⚠️',
            error: '❌',
            debug: '🐛'
        };
        return emojis[level.toLowerCase()] || '📝';
    }

    // Métodos de conveniência
    async info(message, data = null) {
        await this.log('info', message, data);
    }

    async success(message, data = null) {
        await this.log('success', message, data);
    }

    async warning(message, data = null) {
        await this.log('warning', message, data);
    }

    async error(message, data = null) {
        await this.log('error', message, data);
    }

    async debug(message, data = null) {
        await this.log('debug', message, data);
    }

    // Ler logs
    async readLogs(lines = 50) {
        try {
            const content = await fs.readFile(this.logPath, 'utf8');
            const logLines = content.trim().split('\n');
            return logLines.slice(-lines).map(line => {
                try {
                    return JSON.parse(line);
                } catch {
                    return { message: line };
                }
            });
        } catch (error) {
            console.log('📁 Arquivo de log não encontrado');
            return [];
        }
    }
}

module.exports = Logger;

const ProductController = require('./controllers/productController');
const CategoryController = require('./controllers/categoryController');
const Logger = require('./utils/logger');

class PadariaSystem {
    constructor() {
        this.productController = new ProductController();
        this.categoryController = new CategoryController();
        this.logger = new Logger();
    }

    // Inicializar sistema
    async init() {
        try {
            console.log('🍞 ===== SISTEMA DA PADARIA =====');
            console.log('🚀 Inicializando sistema...');
            
            await this.logger.info('Sistema da Padaria iniciado');
            
            // Criar categorias padrão
            await this.createDefaultCategories();
            
            // Criar produtos de exemplo
            await this.createSampleProducts();
            
            // Demonstrar funcionalidades
            await this.demonstrateFeatures();
            
            console.log('\n✅ Sistema inicializado com sucesso!');
            
        } catch (error) {
            await this.logger.error('Erro ao inicializar sistema', { error: error.message });
            console.error('❌ Erro ao inicializar:', error.message);
        }
    }

    // Criar categorias padrão
    async createDefaultCategories() {
        console.log('\n📂 Criando categorias padrão...');
        
        const defaultCategories = [
            { name: 'Pães', description: 'Pães frescos e artesanais' },
            { name: 'Doces', description: 'Doces e sobremesas deliciosas' },
            { name: 'Salgados', description: 'Salgados assados e fritos' },
            { name: 'Bebidas', description: 'Bebidas quentes e frias' }
        ];

        for (const categoryData of defaultCategories) {
            try {
                await this.categoryController.createCategory(categoryData);
                await this.logger.success(`Categoria criada: ${categoryData.name}`);
            } catch (error) {
                if (error.message.includes('já existe')) {
                    console.log(`⚠️ Categoria "${categoryData.name}" já existe`);
                } else {
                    await this.logger.error(`Erro ao criar categoria ${categoryData.name}`, { error: error.message });
                }
            }
        }
    }

    // Criar produtos de exemplo
    async createSampleProducts() {
        console.log('\n🥖 Criando produtos de exemplo...');
        
        const sampleProducts = [
            { name: 'Pão Francês', price: 0.50, category: 'Pães', description: 'Pão francês tradicional' },
            { name: 'Pão de Açúcar', price: 4.50, category: 'Pães', description: 'Pão doce com açúcar cristal' },
            { name: 'Brigadeiro', price: 2.00, category: 'Doces', description: 'Brigadeiro tradicional' },
            { name: 'Coxinha', price: 3.50, category: 'Salgados', description: 'Coxinha de frango' },
            { name: 'Café Expresso', price: 2.50, category: 'Bebidas', description: 'Café expresso forte' }
        ];

        for (const productData of sampleProducts) {
            try {
                await this.productController.createProduct(productData);
                await this.logger.success(`Produto criado: ${productData.name}`);
            } catch (error) {
                await this.logger.error(`Erro ao criar produto ${productData.name}`, { error: error.message });
            }
        }
    }

    // Demonstrar funcionalidades
    async demonstrateFeatures() {
        console.log('\n🎯 Demonstrando funcionalidades...');
        
        try {
            // Listar todos os produtos
            console.log('\n📋 Todos os produtos:');
            const allProducts = await this.productController.getAllProducts();
            allProducts.forEach(product => {
                console.log(`  • ${product.name} - R$ ${product.price.toFixed(2)} (${product.category})`);
            });

            // Listar todas as categorias
            console.log('\n📂 Todas as categorias:');
            const allCategories = await this.categoryController.getAllCategories();
            allCategories.forEach(category => {
                console.log(`  • ${category.name}: ${category.description}`);
            });

            // Buscar produtos por categoria
            console.log('\n🥖 Produtos da categoria "Pães":');
            const paes = await this.productController.getProductsByCategory('Pães');
            paes.forEach(product => {
                console.log(`  • ${product.name} - R$ ${product.price.toFixed(2)}`);
            });

            // Demonstrar atualização de produto
            if (allProducts.length > 0) {
                const firstProduct = allProducts[0];
                console.log(`\n✏️ Atualizando produto "${firstProduct.name}"...`);
                await this.productController.updateProduct(firstProduct.id, {
                    price: firstProduct.price + 0.10
                });
            }

            await this.logger.success('Demonstração concluída com sucesso');
            
        } catch (error) {
            await this.logger.error('Erro durante demonstração', { error: error.message });
            console.error('❌ Erro durante demonstração:', error.message);
        }
    }

    // Exibir menu interativo
    async showMenu() {
        console.log('\n🍞 ===== MENU DO SISTEMA =====');
        console.log('1. Listar todos os produtos');
        console.log('2. Listar todas as categorias');
        console.log('3. Buscar produtos por categoria');
        console.log('4. Criar novo produto');
        console.log('5. Criar nova categoria');
        console.log('6. Ver logs do sistema');
        console.log('0. Sair');
        console.log('================================');
    }
}

// Função principal
async function main() {
    const sistema = new PadariaSystem();
    await sistema.init();
    
    // Exibir menu
    await sistema.showMenu();
    
    console.log('\n🎉 Obrigado por usar o Sistema da Padaria!');
    console.log('💡 Para interação completa, implemente readline para menu interativo');
}

// Executar apenas se for o arquivo principal
if (require.main === module) {
    main().catch(error => {
        console.error('❌ Erro fatal:', error.message);
        process.exit(1);
    });
}

module.exports = PadariaSystem;

{
  "name": "sistema-padaria",
  "version": "1.0.0",
  "description": "Sistema completo para gerenciamento de padaria",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "dev": "node app.js",
    "test": "node test.js"
  },
  "keywords": [
    "padaria",
    "nodejs",
    "sistema",
    "gerenciamento"
  ],
  "author": "Aluno do Curso",
  "license": "MIT",
  "engines": {
    "node": ">=14.0.0"
  }
}

const PadariaSystem = require('./app');
const ProductController = require('./controllers/productController');
const CategoryController = require('./controllers/categoryController');
const Logger = require('./utils/logger');

async function runTests() {
    console.log('🧪 ===== EXECUTANDO TESTES =====');
    
    try {
        // Teste 1: Criar controllers
        console.log('\n✅ Teste 1: Criando controllers...');
        const productController = new ProductController();
        const categoryController = new CategoryController();
        const logger = new Logger();
        console.log('✅ Controllers criados com sucesso!');
        
        // Teste 2: Criar categoria
        console.log('\n✅ Teste 2: Criando categoria de teste...');
        const testCategory = await categoryController.createCategory({
            name: 'Teste',
            description: 'Categoria para testes'
        });
        console.log('✅ Categoria de teste criada!');
        
        // Teste 3: Criar produto
        console.log('\n✅ Teste 3: Criando produto de teste...');
        const testProduct = await productController.createProduct({
            name: 'Produto Teste',
            price: 5.99,
            category: 'Teste',
            description: 'Produto para testes'
        });
        console.log('✅ Produto de teste criado!');
        
        // Teste 4: Listar produtos
        console.log('\n✅ Teste 4: Listando produtos...');
        const products = await productController.getAllProducts();
        console.log(`✅ ${products.length} produtos encontrados!`);
        
        // Teste 5: Sistema completo
        console.log('\n✅ Teste 5: Testando sistema completo...');
        const sistema = new PadariaSystem();
        await sistema.init();
        console.log('✅ Sistema completo testado!');
        
        console.log('\n🎉 ===== TODOS OS TESTES PASSARAM! =====');
        console.log('✅ O sistema está funcionando perfeitamente!');
        console.log('🚀 Você pode executar: node app.js');
        
    } catch (error) {
        console.error('❌ Erro durante os testes:', error.message);
        console.error('🔧 Verifique se todos os arquivos foram criados corretamente');
    }
}

// Executar testes
if (require.main === module) {
    runTests();
}

module.exports = runTests;