Webshop/server.js

const express = require('express');
const session = require('express-session');
const path = require('path');
const bcrypt = require('bcrypt')
const mysql = require('mysql');
const app = express();

require('dotenv').config({path: 'process.env'});

// Datenbankverbindung
const db = mysql.createConnection({
    host: 'localhost', user: 'root', password: '', database: 'webshop'
});

// Verbindung zur MySQL-Datenbank herstellen
db.connect(err => {
    if (err) {
        console.error('Fehler beim Verbinden zur Datenbank:', err);
        return;
    }
    console.log('Mit der Datenbank verbunden');
});

app.use(session({
    secret: 'secret', resave: true, saveUninitialized: true
}));

app.use(express.json());
app.use(express.urlencoded({extended: true}));
app.use(express.static(path.join(__dirname, '/scripts')));
app.use(express.static(path.join(__dirname, '/static')));

// API-Route für Produkte
app.get('/api/products', (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

// API-Route für die 5 neuen Produkte
app.get('/api/products/new', async (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product ORDER BY created_at DESC LIMIT 4';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

// API-Route für die Motorrad-Produkte
app.get('/api/products/motorrad', async (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product WHERE category_id = 4';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

// API-Route für die Oldtimer-Produkte
app.get('/api/products/oldtimer', async (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product WHERE category_id = 2';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

// API-Route für die Lkw-Produkte
app.get('/api/products/lkw', async (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product WHERE category_id = 3';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

// API-Route für die Sportwagen-Produkte
app.get('/api/products/sportwagen', async (req, res) => {
    // SQL-Abfrage für Produktdaten
    const sql = 'SELECT * FROM webshop.product WHERE category_id = 1';

    // Abfrage ausführen
    db.query(sql, (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produkte:', err);
            res.status(500).send('Fehler beim Abrufen der Produkte');
            return;
        }
        res.json(results);  // Rückgabe der Produktdaten als JSON
    });
});

app.post('/api/user/registration', async (req, res) => {
    // SQL-Query für Nutzerregistration
    const {name, lower_name, email, passwd} = req.body;

    try {
        const hashedPassword = await bcrypt.hash(passwd, 10)

        const sql = "INSERT INTO webshop.user (name, lower_name, email, passwd, passwd_hash_algo) VALUES (?, ?, ?, ?, 'bcrypt')"

        // Query abschicken
        db.query(sql, [name, lower_name, email, hashedPassword], (err, results) => {
            if (err) {
                if (err.code === 'ER_DUP_ENTRY') {
                    res.status(409).json({message: 'Diese E-Mail Adresse ist bereits registriert.'})
                }
                console.error('Fehler beim Schreiben in die Datenbank: ', err);
                res.status(500).send('Fehler beim Schreiben in die Datenbank');
                return;
            }
            res.status(201).json({message: 'Nutzer erfolgreich hinzugefügt', id: results.insertId})
        })
    } catch (error) {
        console.error('Hashing-Fehler: ', error)
        res.status(500).json({message: 'Fehler bei der Verarbeitung'})
    }
})

app.post('/api/user/login', (req, res) => {
    const {email, password} = req.body
    const sql = 'SELECT id, email, name, lower_name, passwd FROM webshop.user WHERE email = ?'

    db.query(sql, [email], async (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen des Nutzers: ', err)
            return res.status(500).json({message: 'Serverfehler'})
        }
        if (results.length === 0) {
            return res.status(401).json({message: 'E-Mail oder Passwort ist ungültig.'})
        }

        const user = results[0]

        try {
            // Vergleiche gegebenes Passwort mit gespeichertem verschlüsseltem Passwort
            const passwordMatch = await bcrypt.compare(password, user.passwd)

            if (!passwordMatch) {
                return res.status(401).json({message: 'E-Mail oder Passwort ist ungültig.'})
            }

            req.session.userId = user.id;
            req.session.email = user.email;
            req.session.vorname = user.name;
            req.session.nachname = user.lower_name;

            // bei erfolgreichem Login Daten ans Frontend geben
            res.json({message: 'Login erfolgreich', id: user.id, name: user.name, lower_name: user.lower_name})

        } catch (compareError) {
            console.error('Fehler beim Verarbeiten der Anfrage: ', compareError)
            return res.status(500).json({message: 'Serverfehler bei der Anmeldung'})
        }
    })
})

app.post('/api/bestellung', (req, res) => {
    const {user_id, produkte} = req.body;
    // produkte erwartet als Array: [{product_id: 1, quantity: 2}, {product_id: 5, quantity: 1}, ...]

    if (!user_id || !Array.isArray(produkte) || produkte.length === 0) {
        return res.status(400).json({message: 'Ungültige Anfrage: user_id oder Produkte fehlen.'});
    }

    // Preise der Produkte abrufen
    const productIds = produkte.map(p => p.product_id);

    const priceQuery = 'SELECT id, price FROM webshop.product WHERE id IN (?)';
    db.query(priceQuery, [productIds], (err, priceResults) => {
        if (err) {
            console.error('Fehler beim Abrufen der Produktpreise:', err);
            return res.status(500).json({message: 'Serverfehler beim Abrufen der Produktpreise.'});
        }

        if (priceResults.length !== productIds.length) {
            return res.status(400).json({message: 'Eines oder mehrere Produkte existieren nicht.'});
        }

        // Total berechnen
        let total = 0;
        produkte.forEach(p => {
            const dbProduct = priceResults.find(pr => pr.id === p.product_id);
            if (dbProduct) {
                total += dbProduct.price * p.quantity;
            }
        });

        const payment_id = 1; // Zahlungssystem-ID (z.B. 1 = Rechnung, 2 = PayPal, ...)

        const sqlOrder = 'INSERT INTO webshop.order_details (user_id, payment_id, total) VALUES (?, ?, ?)';
        db.query(sqlOrder, [user_id, payment_id, total], (err1, result1) => {
            if (err1) {
                console.error('Fehler beim Erstellen der Bestellung:', err1);
                return res.status(500).json({message: 'Fehler beim Erstellen der Bestellung.'});
            }

            const orderId = result1.insertId;

            const values = produkte.map(p => [user_id, p.product_id, p.quantity, orderId]);
            const sqlItems = 'INSERT INTO webshop.order_items (user_id, product_id, quantity, order_id) VALUES ?';

            db.query(sqlItems, [values], (err2) => {
                if (err2) {
                    console.error('Fehler beim Einfügen der Order-Items:', err2);
                    return res.status(500).json({message: 'Fehler beim Hinzufügen der Produkte zur Bestellung.'});
                }

                res.status(201).json({message: 'Bestellung erfolgreich!', order_id: orderId, total: total.toFixed(2)});
            });
        });
    });
});

app.post('/api/bestellung/daten', (req, res) => {
    const {user_id} = req.body;

    const sql = `
        SELECT od.id    AS order_id,
               od.total AS order_total,
               oi.product_id,
               oi.quantity,
               p.name   AS product_name,
               p.price  AS product_price
        FROM webshop.order_details od
                 INNER JOIN
             webshop.order_items oi ON od.id = oi.order_id
                 INNER JOIN
             webshop.product p ON oi.product_id = p.id
        WHERE od.user_id = ?
        ORDER BY od.id DESC
    `;

    db.query(sql, [user_id], (err, results) => {
        if (err) {
            console.error('Fehler beim Abrufen der Bestellungen: ', err);
            return res.status(500).json({message: 'Fehler beim Abrufen der Bestellungen'});
        }

        if (results.length === 0) {
            return res.status(404).json({message: 'Keine Bestellungen gefunden.'});
        }

        res.json(results);
    });
});

app.get('/api/pruefe-artikel', (req, res) => {
    const artikelnummer = req.query.nummer;

    if (!artikelnummer) {
        return res.status(400).json({error: 'Keine Artikelnummer angegeben.'});
    }

    const query = 'SELECT id FROM webshop.product WHERE id = ?';

    db.query(query, [artikelnummer], (err, results) => {
        if (err) {
            console.error('Fehler bei der Artikelsuche:', err);
            return res.status(500).json({error: 'Serverfehler bei der Artikelsuche.'});
        }

        const verfuegbar = results.length > 0;
        res.json({verfuegbar});
    });
});

const getIndexRoute = require('./scripts/routes/other/route-index');
app.use('/', getIndexRoute);

// Hier werden alle anderen Seiten abgefangen, die keine definierten Routen haben (404 Fehler) und gibt die 404.html aus
app.use((req, res) => {
    // Setzt den Statuscode auf 404 und sendet die '404.html'-Datei
    res.status(404).sendFile(path.join(__dirname, 'public', '404.html'));
});

// Sever starten
app.listen(process.env.APP_PORT, () => {
    console.log("\x1b[32m");
    console.log(`Server is running on http://localhost:${process.env.APP_PORT}`);
    console.log("\x1b[0m");
    console.log('Access it now...');
});