strapi-plugin-magic-link-v5 4.0.0

package/server/src/controllers/controller.js

@@ -0,0 +1,213 @@
+'use strict';
+
+module.exports = {
+  async getSettings(ctx) {
+    try {
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const settings = await pluginStore.get({ key: 'settings' });
+      
+      // Stelle sicher, dass alle Boolean-Werte korrekt formatiert sind
+      const processedSettings = { ...settings };
+      
+      // Entferne verschachtelte settings-Objekte, falls vorhanden
+      if (processedSettings && processedSettings.settings) {
+        delete processedSettings.settings;
+      }
+      
+      // Verarbeite alle Eigenschaften, die als Boolean behandelt werden sollten
+      const booleanFields = [
+        'enabled', 'createUserIfNotExists', 'stays_valid', 'verify_email', 
+        'welcome_email', 'use_jwt_token', 'allow_magic_links_on_public_registration',
+        'store_login_info', 'use_email_designer'
+      ];
+      
+      booleanFields.forEach(field => {
+        if (field in processedSettings) {
+          // Konvertiere zu echten Boolean-Werten
+          processedSettings[field] = !!processedSettings[field];
+        }
+      });
+      
+      // Ensure store_login_info has a value
+      if (processedSettings.store_login_info === undefined) {
+        processedSettings.store_login_info = true;
+      }
+      
+      // Ensure email designer settings have values
+      if (processedSettings.use_email_designer === undefined) {
+        processedSettings.use_email_designer = false;
+      }
+      
+      if (processedSettings.email_designer_template_id === undefined) {
+        processedSettings.email_designer_template_id = '';
+      }
+      
+      // Korrigiere den Login-Pfad, wenn er den alten Wert hat
+      if (processedSettings.login_path === '/passwordless-login' || processedSettings.login_path === '/api/magic-link/login') {
+        processedSettings.login_path = '/magic-link/login';
+      }
+
+      // Check if Email Designer plugin is installed
+      const isEmailDesignerInstalled = !!strapi.plugin('email-designer-5');
+      
+      ctx.send({ 
+        settings: processedSettings,
+        emailDesignerInstalled: isEmailDesignerInstalled
+      });
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  },
+
+  async updateSettings(ctx) {
+    const { body } = ctx.request;
+
+    try {
+      // Stelle sicher, dass alle Boolean-Werte korrekt formatiert sind
+      const processedBody = { ...body };
+      
+      // Entferne verschachtelte settings-Objekte, falls vorhanden
+      if (processedBody && processedBody.settings) {
+        delete processedBody.settings;
+      }
+      
+      // Verarbeite alle Eigenschaften, die als Boolean behandelt werden sollten
+      const booleanFields = [
+        'enabled', 'createUserIfNotExists', 'stays_valid', 'verify_email', 
+        'welcome_email', 'use_jwt_token', 'allow_magic_links_on_public_registration',
+        'store_login_info', 'use_email_designer'
+      ];
+      
+      booleanFields.forEach(field => {
+        if (field in processedBody) {
+          // Konvertiere verschiedene Formate zu echten Boolean-Werten
+          if (typeof processedBody[field] === 'string') {
+            processedBody[field] = processedBody[field] === 'true';
+          } else if (typeof processedBody[field] === 'object' && processedBody[field]?.type === 'boolean') {
+            processedBody[field] = !!processedBody[field].value;
+          } else {
+            processedBody[field] = !!processedBody[field];
+          }
+        }
+      });
+      
+      // Ensure store_login_info is included in the stored settings
+      if (processedBody.store_login_info === undefined) {
+        processedBody.store_login_info = true;
+      }
+      
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      await pluginStore.set({ key: 'settings', value: processedBody });
+      ctx.send({ settings: processedBody });
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  },
+
+  async index(ctx) {
+    ctx.body = { message: 'Welcome to Magic Link plugin!' };
+  },
+
+  /**
+   * Setzt alle Magic Link Daten und Einstellungen zurück
+   * @param {Object} ctx - Context
+   */
+  async resetData(ctx) {
+    try {
+      // Plugin Store für die Einstellungen
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+
+      // Standardeinstellungen definieren
+      const defaultSettings = {
+        enabled: true,
+        createUserIfNotExists: false,
+        stays_valid: false,
+        expire_period: 3600,
+        token_length: 20,
+        max_login_attempts: 5,
+        login_path: '/magic-link/login',
+        confirmationUrl: process.env.FRONTEND_URL || 'http://localhost:3000',
+        store_login_info: true,
+        default_role: 'authenticated',
+        object: 'Your Magic Link for Login',
+        from_name: 'Magic Link Service',
+        from_email: 'noreply@example.com',
+        message_html: `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="x-ua-compatible" content="ie=edge">
+  <title>Magic Link Login</title>
+</head>
+<body>
+  <h2>Magic Link Login</h2>
+  <p>Click the link below to log in:</p>
+  <p><a href="<%= URL %>?loginToken=<%= CODE %>">Log in to your account</a></p>
+  <p>Or use this URL: <%= URL %>?loginToken=<%= CODE %></p>
+  <p>This link will expire in 1 hour.</p>
+</body>
+</html>`,
+        message_text: `Hello,
+
+Click the link below to log in:
+
+<%= URL %>?loginToken=<%= CODE %>
+
+This link will expire in 1 hour.`,
+        jwt_token_expires_in: '30d'
+      };
+
+      // Einstellungen zurücksetzen
+      await pluginStore.set({ key: 'settings', value: defaultSettings });
+
+      // Alle Magic Link Tokens löschen
+      await strapi.db.query('plugin::magic-link.token').deleteMany({
+        where: {},
+      });
+
+      // JWT Sessions löschen
+      try {
+        await pluginStore.delete({ key: 'jwt_sessions' });
+      } catch (error) {
+        console.error('Fehler beim Löschen der JWT Sessions:', error);
+      }
+
+      // Gebannte IPs zurücksetzen
+      try {
+        await pluginStore.set({ key: 'banned_ips', value: { ips: [] } });
+      } catch (error) {
+        console.error('Fehler beim Zurücksetzen der gebannten IPs:', error);
+      }
+
+      // Gesperrte JWT-Tokens zurücksetzen
+      try {
+        await pluginStore.set({ key: 'blocked_jwt_tokens', value: { tokens: [] } });
+      } catch (error) {
+        console.error('Fehler beim Zurücksetzen der gesperrten JWT-Tokens:', error);
+      }
+
+      // Erfolgreiche Antwort senden
+      ctx.send({
+        success: true,
+        message: 'Alle Magic Link Daten wurden zurückgesetzt.',
+      });
+    } catch (error) {
+      console.error('Fehler beim Zurücksetzen der Magic Link Daten:', error);
+      ctx.throw(500, error);
+    }
+  },
+};

package/server/src/controllers/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Controllers
+ */
+const controller = require('./controller');
+const auth = require('./auth');
+const tokens = require('./tokens');
+const jwt = require('./jwt');
+
+module.exports = {
+  controller,
+  auth,
+  tokens,
+  jwt,
+};

package/server/src/controllers/jwt.js

@@ -0,0 +1,261 @@
+'use strict';
+
+/**
+ * JWT controller für die Verwaltung von JWT-Tokens
+ */
+
+module.exports = {
+  /**
+   * Alle aktiven JWT-Sessions abrufen
+   * @param {Object} ctx - Koa-Kontext
+   */
+  async getSessions(ctx) {
+    try {
+      // Aus dem Plugin-Store auslesen
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const storedData = await pluginStore.get({ key: 'jwt_sessions' }) || { sessions: [] };
+      const jwtSessions = storedData.sessions || [];
+      
+      // Aktuelles Datum für Ablaufprüfung
+      const now = new Date();
+      
+      // Aufbereitung der Daten für die Anzeige
+      const sessions = jwtSessions.map(session => ({
+        id: session.id,
+        userId: session.userId,
+        username: session.username,
+        email: session.userEmail,
+        token: session.jwtToken ? session.jwtToken.substring(0, 30) + '...' : 'N/A', // Nur Teile des Tokens anzeigen
+        createdAt: session.createdAt,
+        expiresAt: session.expiresAt,
+        ipAddress: session.ipAddress,
+        userAgent: session.userAgent || 'Unbekannt',
+        source: session.source || 'Magic Link Login',
+        revoked: session.isRevoked,
+        isExpired: new Date(session.expiresAt) < now
+      }));
+      
+      ctx.send(sessions);
+    } catch (error) {
+      console.error('Error fetching JWT sessions:', error);
+      ctx.throw(500, error);
+    }
+  },
+
+  /**
+   * Ein JWT-Token sperren
+   * @param {Object} ctx - Koa-Kontext
+   */
+  async revokeToken(ctx) {
+    try {
+      const { token, sessionId } = ctx.request.body;
+      
+      // Hole aktuelle JWT-Sessions
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const storedData = await pluginStore.get({ key: 'jwt_sessions' }) || { sessions: [] };
+      let jwtSessions = storedData.sessions || [];
+      
+      // Möglichkeit 1: Sperren über sessionId
+      if (sessionId) {
+        // Finde die Session anhand der ID
+        const sessionIndex = jwtSessions.findIndex(s => s.id === sessionId);
+        
+        if (sessionIndex === -1) {
+          return ctx.badRequest('Session not found');
+        }
+        
+        // Markiere Session als gesperrt
+        jwtSessions[sessionIndex].isRevoked = true;
+        jwtSessions[sessionIndex].revokedAt = new Date().toISOString();
+        jwtSessions[sessionIndex].revokeReason = 'Manually revoked from admin UI';
+        
+        // Sperrung auch in der Sperrliste erfassen
+        if (jwtSessions[sessionIndex].jwtToken) {
+          const { magicLink } = strapi.plugins['magic-link'].services;
+          await magicLink.blockJwtToken(
+            jwtSessions[sessionIndex].jwtToken,
+            jwtSessions[sessionIndex].userId,
+            'Manually revoked from admin UI'
+          );
+        }
+        
+        // Speichere aktualisierte Liste
+        await pluginStore.set({ key: 'jwt_sessions', value: { sessions: jwtSessions } });
+        
+        return ctx.send({ 
+          success: true, 
+          message: 'JWT session revoked successfully' 
+        });
+      }
+      
+      // Möglichkeit 2: Sperren über Token (Legacy)
+      if (token) {
+        const { magicLink } = strapi.plugins['magic-link'].services;
+        const result = await magicLink.blockJwtToken(
+          token, 
+          ctx.request.body.userId || 'unknown', 
+          'Manually revoked from admin UI'
+        );
+        
+        // Auch alle Sessions mit diesem Token sperren
+        const tokenPrefix = token.substring(0, 30);
+        
+        jwtSessions = jwtSessions.map(session => {
+          // Prüfe, ob der Token-Anfang übereinstimmt
+          if (session.jwtToken && session.jwtToken.startsWith(tokenPrefix)) {
+            return {
+              ...session,
+              isRevoked: true,
+              revokedAt: new Date().toISOString(),
+              revokeReason: 'Manually revoked from admin UI via token'
+            };
+          }
+          return session;
+        });
+        
+        // Speichere aktualisierte Liste
+        await pluginStore.set({ key: 'jwt_sessions', value: { sessions: jwtSessions } });
+        
+        return ctx.send({ 
+          success: true,
+          message: "Die Session wurde erfolgreich gesperrt."
+        });
+      }
+      
+      return ctx.badRequest('Token or sessionId is required');
+    } catch (error) {
+      console.error('Error revoking JWT token:', error);
+      ctx.throw(500, error);
+    }
+  },
+
+  /**
+   * Ein JWT-Token entsperren
+   * @param {Object} ctx - Koa-Kontext
+   */
+  async unrevokeToken(ctx) {
+    try {
+      const { sessionId, userId } = ctx.request.body;
+      
+      if (!sessionId) {
+        return ctx.badRequest('Session ID is required');
+      }
+      
+      // Hole aktuelle JWT-Sessions
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const storedData = await pluginStore.get({ key: 'jwt_sessions' }) || { sessions: [] };
+      let jwtSessions = storedData.sessions || [];
+      
+      // Finde die Session anhand der ID
+      const sessionIndex = jwtSessions.findIndex(s => s.id === sessionId);
+      
+      if (sessionIndex === -1) {
+        return ctx.badRequest('Session not found');
+      }
+      
+      // Prüfe, ob die Session abgelaufen ist
+      const expiresAt = new Date(jwtSessions[sessionIndex].expiresAt);
+      const now = new Date();
+      
+      if (expiresAt < now) {
+        return ctx.badRequest('Cannot unrevoke an expired session');
+      }
+      
+      // Session entsperren
+      jwtSessions[sessionIndex].isRevoked = false;
+      jwtSessions[sessionIndex].revokedAt = null;
+      jwtSessions[sessionIndex].revokeReason = null;
+      
+      // Token aus der Sperrliste entfernen, falls vorhanden
+      if (jwtSessions[sessionIndex].jwtToken) {
+        const { magicLink } = strapi.plugins['magic-link'].services;
+        
+        try {
+          // JWT von der Blacklist entfernen
+          await magicLink.unblockJwtToken(
+            jwtSessions[sessionIndex].jwtToken,
+            userId || jwtSessions[sessionIndex].userId
+          );
+        } catch (error) {
+          console.warn('Warning: Could not unblock JWT token from blacklist:', error);
+          // Fehler ignorieren, da der Token möglicherweise nicht in der Blacklist ist
+        }
+      }
+      
+      // Speichere aktualisierte Liste
+      await pluginStore.set({ key: 'jwt_sessions', value: { sessions: jwtSessions } });
+      
+      return ctx.send({ 
+        success: true, 
+        message: 'JWT session unrevoked successfully' 
+      });
+    } catch (error) {
+      console.error('Error unrevoking JWT token:', error);
+      ctx.throw(500, error);
+    }
+  },
+  
+  /**
+   * Alle abgelaufenen und gesperrten Sessions aufräumen
+   * @param {Object} ctx - Koa-Kontext 
+   */
+  async cleanupSessions(ctx) {
+    try {
+      const now = new Date();
+      
+      // Hole aktuelle JWT-Sessions
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const storedData = await pluginStore.get({ key: 'jwt_sessions' }) || { sessions: [] };
+      let jwtSessions = storedData.sessions || [];
+      
+      // Identifiziere abgelaufene Sessions
+      const expiredSessionIds = [];
+      
+      jwtSessions = jwtSessions.map(session => {
+        // Prüfe, ob abgelaufen und nicht bereits gesperrt
+        if (new Date(session.expiresAt) < now && !session.isRevoked) {
+          expiredSessionIds.push(session.id);
+          return {
+            ...session,
+            isRevoked: true,
+            revokedAt: now.toISOString(),
+            revokeReason: 'Automatically expired'
+          };
+        }
+        return session;
+      });
+      
+      // Speichere aktualisierte Liste
+      await pluginStore.set({ key: 'jwt_sessions', value: { sessions: jwtSessions } });
+      
+      ctx.send({ 
+        success: true, 
+        count: expiredSessionIds.length,
+        message: `${expiredSessionIds.length} abgelaufene Sessions wurden aufgeräumt.`
+      });
+    } catch (error) {
+      console.error('Error cleaning up sessions:', error);
+      ctx.throw(500, error);
+    }
+  }
+};