Source: app.js

  1. /**
  2.  * Diese Datei initialisiert und konfiguriert den Server, einschließlich Middleware, Routen, Datenbankverbindungen und Sicherheitskonfigurationen für eine vollständige Backend-Anwendung.
  3.  * 
  4.  * @file app.js - Express Server Hauptanwendung
  5.  * @author Farah, Ayoub, Luca, Miray, Ilyass, Lennart
  6.  * @copyright 2024
  7.  * @requires cors
  8.  * @requires express
  9.  * @requires body-parser
  10.  * @requires path
  11.  * @requires express-session
  12.  * @requires ./sequelize.config
  13.  */
  15. const cors = require("cors");
  16. const express = require("express");
  17. const app = express();
  18. const bodyParser = require("body-parser");
  19. const path = require("path");
  20. const session = require("express-session");
  21. const sequelize = require("./sequelize.config.js");
  23. // Import routes
  24. const authRoutes = require('./backend/routes/authRoutes');
  25. const docUploadRoutes = require("./backend/routes/docUploadRoutes");
  26. const foldersRoutes = require("./backend/routes/foldersRoutes");
  27. const semanticSearchRoutes = require('./backend/routes/semanticSearchRoutes');
  28. const adminRoutes = require('./backend/routes/adminRoutes');
  29. const passwordResetRoutes = require('./backend/models/passwordReset');
  30. const {registerUser, verifyUserCode} = require ('./backend/models/userRegistrationToDB.js');
  31. const monitorRoutes = require('./backend/routes/monitorRoutes.js');
  33. // Import models
  34. const User = require("./database/User");
  35. const Folder = require("./database/Folder");
  36. const File = require("./database/File");
  37. const UserRole = require("./database/UserRole");
  38. const UserRoleMapping = require("./database/UserRoleMapping");
  40. const PORT = process.env.PORT || 3000;
  42. /**
  43.  * CORS-Konfiguration
  44.  * @name CORSConfiguration
  45.  * @memberof module:middleware
  46.  * @property {string} origin - Erlaubte Origin für CORS
  47.  * @property {string[]} methods - Erlaubte HTTP-Methoden
  48.  * @property {boolean} credentials - Erlaubt Credentials in CORS-Requests
  49.  */
  50. app.use(
  51.   cors({
  52.     origin: "http://localhost:5173",
  53.     methods: ["POST", "PUT", "GET", "DELETE", "OPTIONS", "HEAD"],
  54.     credentials: true,
  55.   })
  56. );
  58. // Basic security headers
  59. app.use((req, res, next) => {
  60.   res.setHeader(
  61.     'Content-Security-Policy',
  62.     "default-src 'self'; style-src 'self' 'unsafe-inline' fonts.googleapis.com; font-src 'self' fonts.gstatic.com; img-src 'self' data: blob:; script-src 'self' 'unsafe-inline' 'unsafe-eval'; connect-src 'self' localhost:* ws://localhost:*"
  63.   );
  64.   next();
  65. });
  67. /**
  68.  * Body-Parser Konfiguration für JSON-Verarbeitung
  69.  * @name BodyParserConfiguration
  70.  * @memberof module:middleware
  71.  */
  72. app.use(express.json());
  74. /**
  75.  * Session-Konfiguration für Express
  76.  * @name SessionConfiguration
  77.  * @memberof module:middleware
  78.  * @property {string} name - Name der Session-ID
  79.  * @property {string} secret - Geheimer Schlüssel für Session-Verschlüsselung
  80.  * @property {boolean} resave - Verhindert das Neu-Speichern unmodifizierter Sessions
  81.  * @property {boolean} saveUninitialized - Verhindert Speichern nicht initialisierter Sessions
  82.  * @property {Object} cookie - Cookie-Konfigurationen
  83.  */
  84. app.use(
  85.   session({
  86.     name: "userId",
  87.     secret: "your_secret_key",
  88.     resave: false,
  89.     saveUninitialized: false,
  90.     cookie: {
  91.       sameSite: false,
  92.       secure: false,
  93.       httpOnly: true,
  94.       maxAge: 24 * 60 * 60 * 1000,
  95.     },
  96.   })
  97. );
  99. /**
  100.  * Modell-Beziehungsdefinitionen
  101.  * @namespace ModelRelationships
  102.  * @description Definiert die Beziehungen zwischen den Datenbank-Modellen
  103.  * @property {Object} User.hasMany.Folder - Ein-zu-viele Beziehung zwischen User und Folder
  104.  * @property {Object} Folder.belongsTo.User - Viele-zu-eins Beziehung zwischen Folder und User
  105.  * @property {Object} Folder.hasMany.Folder - Selbstreferenzierende Beziehung für Unterordner
  106.  * @property {Object} User.hasMany.File - Ein-zu-viele Beziehung zwischen User und File
  107.  * @property {Object} Folder.hasMany.File - Ein-zu-viele Beziehung zwischen Folder und File
  108.  * @property {Object} UserRoleMapping - Verknüpfungstabelle zwischen User und UserRole
  109.  * 
  110.  * Datenbank-Initialisierung und Beziehungsdefinition zwischen Models
  111.  * @name DatabaseSetup
  112.  * @async
  113.  * @function
  114.  * @throws {Error} Wenn die Datenbankverbindung oder Synchronisation fehlschlägt
  115.  */
  116. (async () => {
  117.   try {
  118.     await sequelize.authenticate();
  119.     console.log("Database connection successful.");
  121.     // Define Model Relationships
  122.     User.hasMany(Folder, { foreignKey: "user_id", onDelete: "CASCADE" });
  123.     Folder.belongsTo(User, { foreignKey: "user_id" });
  125.     Folder.hasMany(Folder, { foreignKey: "parent_folder_id", as: "subfolders", onDelete: "SET NULL" });
  126.     Folder.belongsTo(Folder, { foreignKey: "parent_folder_id", as: "parentFolder" });
  128.     User.hasMany(File, { foreignKey: "user_id", onDelete: "CASCADE" });
  129.     File.belongsTo(User, { foreignKey: "user_id" });
  131.     Folder.hasMany(File, { foreignKey: "folder_id", onDelete: "SET NULL" });
  132.     File.belongsTo(Folder, { foreignKey: "folder_id" });
  134.     UserRoleMapping.belongsTo(User, { foreignKey: "user_id" });
  135.     UserRoleMapping.belongsTo(UserRole, { foreignKey: "role_id" });
  136.     
  137.     User.belongsToMany(UserRole, { through: UserRoleMapping, foreignKey: "user_id" });
  138.     UserRole.belongsToMany(User, { through: UserRoleMapping, foreignKey: "role_id" });
  140.     await sequelize.sync();
  141.     console.log("Database synchronization successful.");
  142.   } catch (error) {
  143.     console.error("Database error:", error);
  144.   }
  145. })();
  147. /**
  148.  * Authentifizierungs-Middleware zur Überprüfung der Benutzeranmeldung
  149.  * @function authenticateMiddleware
  150.  * @param {express.Request} req - Express Request Objekt
  151.  * @param {express.Response} res - Express Response Objekt
  152.  * @param {express.NextFunction} next - Express Next Middleware Funktion
  153.  * @returns {void}
  154.  */
  155. const authenticateMiddleware = (req, res, next) => {
  156.   if (req.session.userId) {
  157.     next();
  158.   } else {
  159.     res.status(401).json({ message: "Unauthorized: Please log in" });
  160.   }
  161. };
  163. app.use('/api/admin', adminRoutes);
  165. /**
  166.  * Route zum Abrufen des Admin-Status
  167.  * @name get/api/admin/status
  168.  * @function
  169.  * @memberof module:routes
  170.  * @param {express.Request} req - Express Request Objekt
  171.  * @param {express.Response} res - Express Response Objekt
  172.  */
  173. app.get("/api/admin/status", (req, res) => {
  174.   if (req.session.isAdmin) {
  175.     res.json({ isAdmin: true });
  176.   } else {
  177.     res.json({ isAdmin: false });
  178.   }
  179. });
  181. /**
  182.  * Route zum Abrufen der aktuellen Benutzerinformationen
  183.  * @name get/api/current-user
  184.  * @function
  185.  * @param {express.Request} req - Express Request Objekt
  186.  * @param {express.Response} res - Express Response Objekt
  187.  * @returns {Object} Objekt mit userId und isAdmin Status
  188.  */
  189. app.get("/api/current-user", authenticateMiddleware, (req, res) => {
  190.   res.json({
  191.     userId: req.session.userId,
  192.     isAdmin: req.session.isAdmin || false,
  193.   });
  194. });
  196. /**
  197.  * Registrierungsroute für neue Benutzer
  198.  * @name post/register
  199.  * @function
  200.  * @async
  201.  * @param {express.Request} req - Express Request Objekt mit username, email und password im Body
  202.  * @param {express.Response} res - Express Response Objekt
  203.  * @throws {Error} Wenn die Registrierung fehlschlägt
  204.  */
  205. app.post("/register", async (req, res) => {
  206.   console.log("Received registration request:", req.body);
  207.   const { username, email, password } = req.body;
  209.   try {
  210.     const userId = await registerUser(username, email, password);
  211.     console.log("User registered successfully:", userId);
  212.     res.status(201).json({
  213.       message: "User registered successfully. Please log in.",
  214.       userId,
  215.     });
  216.   } catch (error) {
  217.     console.error("Error registering user:", error);
  218.     if (error.message === "Username or email already exists") {
  219.       res.status(400).json({ message: error.message });
  220.     } else if (error.message === "Failed to insert user: No ID returned") {
  221.       res.status(500).json({
  222.         message:
  223.           "User was created but an error occurred. Please contact support.",
  224.       });
  225.     } else {
  226.       res.status(500).json({
  227.         message: "An unexpected error occurred. Please try again later.",
  228.       });
  229.     }
  230.   }
  231. });
  233. /**
  234.  * Verifizierungsroute für Benutzer-Codes
  235.  * @name post/api/verify-code
  236.  * @function
  237.  * @async
  238.  * @param {express.Request} req - Express Request Objekt mit email und verificationCode im Body
  239.  * @param {express.Response} res - Express Response Objekt
  240.  * @throws {Error} Wenn die Verifizierung fehlschlägt
  241.  */
  242. app.post('/api/verify-code', async (req, res) => {
  243.     const { email, verificationCode } = req.body;
  245.     if (!email || !verificationCode) {
  246.         return res.status(400).json({ message: 'Email und verification key sind notwendig' });
  247.     }
  249.     try {
  250.         const result = await verifyUserCode(email, verificationCode);
  252.         if (result.success) {
  253.             res.status(200).json({ message: result.message });
  254.         } else {
  255.             res.status(400).json({ message: result.message });
  256.         }
  257.     } catch (error) {
  258.         console.error(error);
  259.         res.status(500).json({ message: 'An error occurred during verification' });
  260.     }
  261. });
  263. // Route Middleware
  264. app.use('/auth', authRoutes);
  265. app.use('/api/admin', adminRoutes);
  266. app.use("/docupload", authenticateMiddleware, docUploadRoutes);
  267. app.use("/folders", authenticateMiddleware, foldersRoutes);
  268. app.use("/search", authenticateMiddleware, semanticSearchRoutes);
  269. app.use("/passwordReset", passwordResetRoutes);
  270. app.use('/monitor', monitorRoutes);
  272. app.use(express.static(path.join(__dirname, "frontend", "dist")));
  274. /**
  275.  * Catch-all Route für Client-seitiges Routing
  276.  * @name get/*
  277.  * @function
  278.  * @param {express.Request} req - Express Request Objekt
  279.  * @param {express.Response} res - Express Response Objekt
  280.  */
  281. app.get("*", (req, res) => {
  282.   console.log(`Catch-All Route hit: ${req.url}`);
  283.   res.sendFile(path.join(__dirname, "frontend", "dist", "index.html"));
  284. });
  286. /**
  287.  * Server-Start Konfiguration
  288.  * @name ServerStart
  289.  * @function
  290.  * @param {number} PORT - Der Port auf dem der Server läuft
  291.  * @listens {number} PORT
  292.  */
  293. app.listen(PORT, () => {
  294.   console.log(`Server running on port ${PORT}`);
  295. });