DELIVER_MAN/server/server.js

import express from "express";
import dotenv from "dotenv"
import { randomUUID } from "crypto";
import DBAdapter, { getCurrentDate, setCurrentDate } from "./db/database.js";
import { DB_INTERNAL_ERROR, DB_USER_ERROR } from "./db/database.js";

dotenv.config({
    path: './server/.env'
});

const {
    HOST,
    PORT,
    DATABASE,
    USER,
    PASSWORD
} = process.env;

const app = express();
app.use(express.json());

const adapter = new DBAdapter({
    dbHost: HOST,
    dbPort: PORT,
    dbName: DATABASE,
    dbUserLogin: USER,
    dbUserPassword: PASSWORD
});

function AddDays(dateString, days) {
    let date = new Date(dateString);
    date.setDate(date.getDate() + days);
    return date.toISOString().slice(0, 10);
}

function Random_Increase() {
    return Math.floor(Math.random() * 5) + 1;
}

app.get('/api/current-date', async (req, res) => {
    let currentDate = await getCurrentDate();
    res.json({ currentDate });
});

app.get('/api/products', async(req, res) => {
    try {
        const db_products = await adapter.getProducts();
        
        const products = db_products.map(
            ( {id, name, quantity} ) => ({
                ID: id,
                pr_name: name,
                count: quantity
            })
        );
        res.statusCode = 200;
        res.message = "OK";
        res.json(products);
    } catch (err){
        res.statusCode = 500;
        res.message = "WHOOPS";
        res.json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
            error : `${err}`
        })
    }
});

app.post('/api/current-date/advance', async (req, res) => {
    let currentDate = await getCurrentDate();
    try {
        const raw_ids = await adapter.getOrdersByDate(currentDate);
        const ids = raw_ids.map(item => item.id);
        await adapter.clearOrders(ids);

        let nextDate = AddDays(currentDate, 1);
        await setCurrentDate(nextDate);
        res.json({ currentDate: nextDate });
    } catch (err){
        res.statusCode = 500;
        res.message = "WHOOPS";
        res.json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
            error : `${err}`
        })
    }
});

app.get('/api/orders', async(req, res) => {
    try {
        const db_orders = await adapter.getOrders();
        
        const orders = db_orders.map(
            ( {id, customer_name, order_date, status, total_amount, items} ) => ({
                ID: id,
                customer: customer_name,
                date: order_date,
                status: status,
                total: total_amount,
                items: items ? items.map(item => ({
                    product_id: item.product_id,
                    product_name: item.product_name || item.name,
                    quantity: item.quantity,
                    price: item.price
                })) : []
            })
        );
        
        res.statusCode = 200;
        res.message = "OK";
        res.json(orders);
        
    } catch (err) {
        res.statusCode = 500;
        res.message = "WHOOPS";
        res.json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
            error: `${err}`
        });
    }
});

app.post('/api/orders', async (req, res) => {
    let { customerName, orderDate } = req.body;
    let id = randomUUID();
    
    try {
        await adapter.addOrder({
            id, 
            customer_name: customerName,
            orderDate
        });
        
        res.status(201).json({
            id, 
            customerName, 
            orderDate
        });
        
    } catch (err) {
        console.log('Error in POST /api/orders:', err);
        switch(err.type) {
            case DB_INTERNAL_ERROR:
                res.status(500).json({
                    timeStamp: new Date().toISOString(),
                    statusCode: 500,
                    error: err.error?.message || err.message
                });
                break;
                    
            case DB_USER_ERROR:
                res.status(400).json({
                    timeStamp: new Date().toISOString(),
                    statusCode: 400,
                    error: err.error?.message || err.message
                });
                break;
                    
            default:
                res.status(500).json({
                    timeStamp: new Date().toISOString(),
                    statusCode: 500,
                    message: "Unknown error",
                    error: err.message
                });        
        }
    }
});

app.delete('/api/orders/:id', async (req, res) => {
    try {
        await adapter.deleteOrderById(req.params.id);
        res.statusCode = 200;
        res.message = "OK";
        res.json({message: "success"});
    } catch (err){
        res.statusCode = 500;
        res.message = "WHOOPS";
        res.json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
            error: `${err}`
        });
    }
})

app.post('/api/orders/:orderId/items', async (req, res) => {
    let orderId = req.params.orderId;
    let { productId, quantity } = req.body;
    
    try {
        await adapter.addOrderItem({
            orderId, 
            productId,
            quantity
        });
        
        res.status(201).json({
            orderId, 
            productId,
            quantity
        });
        
    } catch (err) {
        // TODO
        res.status(500).json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
        });
    }
});

app.put('/api/orders/:orderId/items/:itemId', async (req, res) => {
    let itemId = req.params.itemId;
    let quantity = req.body.quantity;
    
    try {
        await adapter.updateOrderItem({
            itemId, 
            quantity
        });
        
        res.status(201).json({
            itemId, 
            quantity
        });
        
    } catch (err) {
        // TODO
        res.status(500).json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
        });
    }
});

app.delete('/api/orders/:orderId/items/:itemId', async (req, res) => {
    try {
        await adapter.deleteOrderItem(req.params.itemId);
        res.statusCode = 204;
        res.message = "OK";
        res.json({message: "success"});
    } catch (err){
        res.statusCode = 500;
        res.message = "WHOOPS";
        res.json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
            error: `${err}`
        });
    }
})

app.post('/api/order-items/:itemId/move', async (req, res) => {
    let itemId = req.params.itemId;
    let targetOrderId = req.body.targetOrderId;
    
    try {
        await adapter.moveOrderItem({
            itemId, 
            targetOrderId,
        });
        
        res.status(201).json({
            itemId, 
            targetOrderId,
        });
        
    } catch (err) {
        // TODO
        res.status(500).json({
            timeStamp: new Date().toISOString(),
            statusCode: 500,
        });
    }
});


app.use((req, res) => {
    res.status(404).json({ error: 'Invalid route' });
});

app.listen(3000, async() => {
    try {
        await adapter.connect();
        console.log(`✅ Server running on port 3000`);
        console.log(`📡 Local: http://localhost:3000`);
    } catch(err){
        console.log("Shutting down application...");
        process.exit(100);
    }
});

process.on('SIGTERM', () => {
    console.log("CLOSE APP");
    app.close( async() => {
        await adapter.disconnect();
        console.log("DB DISCONNECTED");
    });
});