Merge pull request #115 from TheRefraction/feature-admin-middleware

Feature admin middleware

Author: TheRefraction

backend/db/mongo/migrations/01-invoice.js

@@ -3,131 +3,53 @@
  */
 
 const migrate = (db, helpers) => {
-    const { createOrModify, ensureIndex } = helpers;
+    const { createOrModify } = helpers;
 
     const invoiceOptionSchema = {
         bsonType: "object",
         required: ["name", "item"],
         description: "An option slot for a product",
         properties: {
             name: {
-                bsonType: "string",
-                description: "Name of the current option slot"
+                bsonType: "string"
             },
             item: {
                 bsonType: "object",
                 required: ["name", "delta", "quantity"],
-                description: "The chosen option",
                 properties: {
-                    name: {
-                        bsonType: "string",
-                        description: "Name of product"
-                    },
-                    delta: {
-                        bsonType: "double",
-                        description: "Price increase or decrease on the product"
-                    },
-                    quantity: {
-                        bsonType: "int",
-                        description: "Number of options selected (between min_select and max_select)",
-                        minimum: 0 
-                    },
+                    name: { bsonType: "string" },
+                    delta: { bsonType: "double" },
+                    quantity: { bsonType: "int", minimum: 0 }
                 }
             }
         }
     };
 
-    const invoiceOptionsSchema = {
-        bsonType: "array",
-        description: "Array of options on a given product (optional)",
-        items: invoiceOptionSchema
-    };
-
-    const invoiceMenuSlotSchema = {
-        bsonType: "object",
-        required: ["name", "item"],
-        description: "A menu slot",
-        properties: {
-            name: {
-                bsonType: "string",
-                description: "Name of the current slot in the menu"
-            },
-            item: {
-                bsonType: "object",
-                required: ["name", "delta", "quantity"],
-                description: "What product has been chosen for this slot",
-                properties: {
-                    name: {
-                        bsonType: "string",
-                        description: "Name of product"
-                    },
-                    delta: {
-                        bsonType: "double",
-                        description: "Price increase or decrease on the product"
-                    },
-                    quantity: {
-                        bsonType: "int",
-                        description: "Number of products selected (between min_select and max_select)",
-                        minimum: 0 // For instance, a dessert can be optional whence the threshold
-                    },
-
-                    // Selected options if any (optional)
-                    options: invoiceOptionsSchema
-                }
-            }
-        }
-    };
-
-    const invoiceMenuSlotsSchema = {
-        bsonType: "array",
-        description: "Used when the item is a menu. Array of menu slots (optional)",
-        items: invoiceMenuSlotSchema
-    };
-
     const invoiceItemSchema = {
         bsonType: "object",
         required: ["type", "name", "price", "quantity"],
-        description: "A given line in the invoice which corresponds to a given item",
         properties: {
             type: {
-                bsonType: "string",
-                enum: ["product", "menu"],
-                description: "Current item is either a product or a menu"
-            },
-            name: {
-                bsonType: "string",
-                description: "This is the name of the item"
+                enum: ["product"], // Restreint au type "product" uniquement
+                bsonType: "string"
             },
-            price: {
-                bsonType: "double",
-                description: "The unit price, must be non negative", // For a menu, the prices of products within are not taken into account
-                minimum: 0
-            },
-            quantity: {
-                bsonType: "int",
-                description: "Quantity of the ordered item, at least 1",
-                minimum: 1
-            },
-
-            // Present when type=product
-            options: invoiceOptionsSchema,
-
-            // Present when type=menu
-            slots: invoiceMenuSlotsSchema
+            name: { bsonType: "string" },
+            price: { bsonType: "double", minimum: 0 },
+            quantity: { bsonType: "int", minimum: 1 },
+            options: {
+                bsonType: "array",
+                items: invoiceOptionSchema
+            }
         }
     };
 
     const invoiceSchema = {
         bsonType: "object",
         required: ["_id", "items"],
         properties: {
-            _id: {
-                bsonType: "int",
-                description: "Mirrors the Postgres invoice.id"
-            },
+            _id: { bsonType: "int" },
             items: {
                 bsonType: "array",
-                description: "An array of invoices items (at least one line)",
                 minItems: 1,
                 items: invoiceItemSchema
             }

backend/package-lock.json

@@ -16,6 +16,7 @@
     "jsonwebtoken": "^9.0.2",
     "mongodb": "^6.8.0",
     "morgan": "^1.10.0",
+    "node-cron": "^4.4.1",
     "pg": "^8.12.0"
   },
   "devDependencies": {
@@ -25,6 +26,7 @@
     "@types/jsonwebtoken": "^9.0.4",
     "@types/morgan": "^1.9.8",
     "@types/node": "^20.19.42",
+    "@types/node-cron": "^3.0.11",
     "@types/pg": "^8.11.6",
     "tsx": "^4.16.0",
     "typescript": "^5.5.0"

backend/package.json

@@ -5,6 +5,7 @@ import morgan from 'morgan';
 import routes from './routes';
 
 import { errorMiddleware, AppError } from './middlewares/error.middleware';
+import { requestLogger } from './middlewares/logger.middleware';
 import { connectMongoDB } from './config/mongo';
 import { pgPool } from './config/postgres';
 import { env } from './config/env';
@@ -45,6 +46,7 @@ class App {
     this.app.use(express.json());
     this.app.use(express.urlencoded({ extended: true }));
     this.app.use(morgan('combined'));
+    this.app.use(requestLogger);
   }
 
   private initializeRoutes(): void {

backend/src/app.ts

@@ -9,6 +9,16 @@ import { InvoiceStatus } from '../models/invoice.model';
 export class InvoiceController extends BaseController {
     constructor(private invoiceSvc: InvoiceService, private paymentSvc: PaymentService) { super(); }
 
+    getAll = async(req: Request, res: Response, next: NextFunction): Promise<void> => {
+        try {
+            const fullInvoice = await this.invoiceSvc.getAll();
+
+            this.sendResponse(res, HttpStatus.OK, 'Invoices retrieved', fullInvoice);
+        } catch (error) {
+            next(error);
+        }
+    }
+
     getById = async(req: Request, res: Response, next: NextFunction): Promise<void>  => {
         try {
             const invoiceId = parseInt(req.params.id);

backend/src/controllers/invoice.controller.ts

@@ -14,7 +14,9 @@ export class ProductController extends BaseController {
 
     getAll = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
         try {
-            const products = await this.productFcd.getAllFullProducts();
+            const showHidden = req.query.showHidden !== 'false';
+            
+            const products = await this.productFcd.getAllFullProducts(showHidden);
 
             this.sendResponse(res, HttpStatus.OK, 'Products retrieved successfully', products);
         } catch (error) {

backend/src/controllers/product.controller.ts

@@ -1,15 +1,18 @@
 import app from './app';
 import { env } from './config/env';
+import { initAccountCleaner } from './jobs/accountCleaner';
 
 const PORT = 3000;
 
 (async () => {
   await app.init();
 
+  initAccountCleaner();
+
   const server = app.getApp().listen(PORT, () => {
     console.log(`Server running on port ${PORT}`);
     console.log(`Environment: ${env.NODE_ENV}`);
-    console.log(`Health check: http://localhost:${PORT}/health`);
+    console.log(`Health check: http://localhost:${PORT}/api/health`);
   });
 
   const gracefulShutdown = () => {

backend/src/index.ts

@@ -0,0 +1,25 @@
+import cron from 'node-cron';
+import { pgPool } from '../config/postgres';
+
+export const initAccountCleaner = () => {
+    // Planifié tous les jours à 03h00 du matin
+    cron.schedule('0 3 * * *', async () => {
+        console.log('[AccountCleaner] Démarrage de la purge des comptes inactifs...');
+        
+        try {
+            // Note: Assurez-vous que vos FK ont 'ON DELETE CASCADE' 
+            // pour supprimer les factures/données liées automatiquement.
+            const query = `
+                DELETE FROM account 
+                WHERE last_login < NOW() - INTERVAL '2 years'
+                OR (last_login IS NULL AND created_at < NOW() - INTERVAL '2 years');
+            `;
+            
+            const result = await pgPool.query(query);
+            
+            console.log(`[AccountCleaner] Succès : ${result.rowCount} comptes supprimés.`);
+        } catch (error) {
+            console.error('[AccountCleaner] Erreur lors de la suppression :', error);
+        }
+    });
+};

backend/src/jobs/accountCleaner.ts

@@ -49,4 +49,16 @@ export const adminMiddleware = async (
         return;
     }
     next();
-};
+};
+
+/*
+UNUSED
+export const authorize = (roles: Role[]) => {
+    return (req: AuthRequest, res: Response, next: NextFunction) => {
+        if (!req.user || !roles.includes(req.user.role)) {
+            res.status(HttpStatus.FORBIDDEN).json({ success: false, message: 'Forbidden' });
+            return;
+        }
+        next();
+    };
+};*/

backend/src/middlewares/auth.middleware.ts

@@ -0,0 +1,38 @@
+import { Request, Response, NextFunction } from 'express';
+import { getCollection } from '../config/mongo';
+import { AuthRequest } from './auth.middleware'; // Réutilisation de votre type
+
+export const requestLogger = async (
+    req: AuthRequest,
+    res: Response,
+    next: NextFunction
+) => {
+    const start = Date.now();
+
+    res.on('finish', async () => {
+        const duration = Date.now() - start;
+
+        try {
+            const logsCollection = getCollection<any>('logs');
+            
+            // Création de l'objet avec des valeurs par défaut pour éviter les "undefined"
+            const logEntry = {
+                timestamp: new Date(),
+                method: req.method || 'GET', 
+                path: req.originalUrl || req.path || '/',
+                status: res.statusCode || 0,
+                duration: Math.round(duration),
+                // userId est optionnel, donc on ne le met que s'il existe
+                ...(req.user?.userId && { userId: String(req.user.userId) }),
+                ip: req.ip || '127.0.0.1'
+            };
+
+            await logsCollection.insertOne(logEntry);
+        } catch (error) {
+            // Loguer l'erreur réelle pour comprendre quel champ manque
+            console.error('Failed to log request:', error);
+        }
+    });
+
+    next();
+};