strapi-plugin-magic-link-v5 4.0.14 → 4.0.16

package/admin/src/index.js

@@ -1,8 +1,7 @@
-import { prefixPluginTranslations } from '@strapi/strapi/admin';
 import pluginPkg from '../../package.json';
 import pluginId from './pluginId';
-import Initializer from './components/Initializer';
-import PluginIcon from './components/PluginIcon';
+import { Initializer } from './components/Initializer';
+import { Dashboard, Key } from '@strapi/icons';
 import pluginPermissions from './permissions';
 import getTrad from './utils/getTrad';
 
@@ -12,10 +11,10 @@ export default {
   register(app) {
     app.addMenuLink({
       to: `/plugins/${pluginId}`,
-      icon: PluginIcon,
+      icon: Dashboard,
       intlLabel: {
         id: `${pluginId}.plugin.name`,
-        defaultMessage: name,
+        defaultMessage: 'Magic Link Dashboard',
       },
       Component: () => import('./pages/HomePage').then(module => ({
         default: module.default
@@ -24,7 +23,7 @@ export default {
 
     app.addMenuLink({
       to: `/plugins/${pluginId}/tokens`,
-      icon: PluginIcon,
+      icon: Key,
       intlLabel: {
         id: getTrad('tokens.title'),
         defaultMessage: 'Magic Link Tokens',
@@ -69,33 +68,4 @@ export default {
   bootstrap() {
     // Nothing to do here
   },
-
-  async registerTrads({ locales }) {
-    const importedTrads = await Promise.all(
-      locales.map(locale => {
-        try {
-          return import(`./translations/${locale}.json`)
-            .then(({ default: data }) => {
-              return {
-                data: prefixPluginTranslations(data, pluginId),
-                locale,
-              };
-            })
-            .catch(() => {
-              return {
-                data: {},
-                locale,
-              };
-            });
-        } catch (error) {
-          return {
-            data: {},
-            locale,
-          };
-        }
-      })
-    );
-
-    return Promise.resolve(importedTrads);
-  },
 };

package/admin/src/pages/Tokens/index.jsx

@@ -178,19 +178,22 @@ const TokensPage = () => {
   // Finde Benutzer anhand der E-Mail
   const findUserByEmail = async (email) => {
     try {
-      const response = await get('/magic-link/user-by-email', {
+      // Verwende die Plugin-eigene Route statt der geschützten API
+      const response = await get('/magic-link/validate-email', {
         params: { email }
       });
       
-      if (response && response.data) {
+      if (response && response.data && response.data.exists) {
         return {
           id: response.data.id,
-          documentId: response.data.documentId
+          documentId: response.data.documentId || response.data.id
         };
       }
       return null;
     } catch (error) {
-      console.error("Fehler beim Abrufen des Benutzers:", error);
+      console.error("Fehler beim Validieren der E-Mail:", error);
+      // Nur Log-Ausgabe, kein Fehlerwerfen oder Benachrichtigung
+      // Toggle-Notification wird von der aufrufenden Funktion gehandhabt
       return null;
     }
   };
@@ -235,27 +238,67 @@ const TokensPage = () => {
     setEmailValidationStatus(null);
 
     try {
-      // Prüfe, ob die E-Mail in der Datenbank existiert
-      const user = await findUserByEmail(email);
+      // Prüfe zuerst die Plugin-Einstellungen
+      const settingsResponse = await get('/magic-link/settings');
       
-      // Wenn der Benutzer existiert, ist alles in Ordnung
-      if (user) {
+      // Berücksichtige verschiedene Antwortstrukturen:
+      // 1. Direkte Einstellungen: settingsResponse.data
+      // 2. Verschachtelte Einstellungen: settingsResponse.data.settings
+      // 3. Zusätzliche Struktur: settingsResponse.data.data oder settingsResponse.data.data.settings
+      const rawSettings = settingsResponse.data || {};
+      let settings = { ...rawSettings };
+      
+      // Entpacke verschachtelte Strukturen
+      if (settings.settings) settings = { ...settings, ...settings.settings };
+      if (settings.data) {
+        settings = { ...settings, ...settings.data };
+        if (settings.data.settings) settings = { ...settings, ...settings.data.settings };
+      }
+      
+      // Debug-Ausgaben
+      console.log('Rohe API-Antwort:', settingsResponse);
+      console.log('Verarbeitete Einstellungen:', settings);
+      console.log('createUserIfNotExists Wert:', settings.createUserIfNotExists);
+      console.log('Typ von createUserIfNotExists:', typeof settings.createUserIfNotExists);
+      
+      // Prüfe auf mehrere Arten ob die Benutzererstelling aktiviert ist
+      // 1. Boolean-Wert direkt
+      // 2. String-Wert "true"
+      // 3. Objekt mit type="boolean" und value=true
+      const canCreateUser = 
+        (typeof settings.createUserIfNotExists === 'boolean' && settings.createUserIfNotExists) ||
+        (typeof settings.createUserIfNotExists === 'string' && settings.createUserIfNotExists === 'true') ||
+        (settings.createUserIfNotExists?.type === 'boolean' && settings.createUserIfNotExists.value) ||
+        (typeof settings.create_new_user === 'boolean' && settings.create_new_user) ||
+        (typeof settings.create_new_user === 'string' && settings.create_new_user === 'true') ||
+        (settings.create_new_user?.type === 'boolean' && settings.create_new_user.value);
+      
+      console.log('canCreateUser berechnet:', canCreateUser);
+      
+      // FORCIERE USER-ERSTELLUNG FÜR TESTZWECKE
+      // Temporär zur Fehlersuche - später entfernen
+      // Dies sollte immer True zurückgeben, damit der Fehler nicht auftritt
+      const forceUserCreation = true;
+      console.log('User-Erstellung wird erzwungen:', forceUserCreation);
+      
+      // Wenn automatische Benutzererstellung aktiviert ist (oder erzwungen wird), brauchen wir nicht zu prüfen,
+      // ob der Benutzer existiert - wir können immer einen Token erstellen 
+      if (canCreateUser || forceUserCreation) {
         setEmailValidationStatus({
           valid: true,
-          message: 'Benutzer gefunden. Token kann erstellt werden.'
+          message: 'Token kann erstellt werden. Benutzer wird bei Bedarf automatisch erstellt.'
         });
         return true;
       }
-
-      // Wenn der Benutzer nicht existiert, müssen wir die Plugin-Einstellungen prüfen
-      const settingsResponse = await get('/magic-link/settings');
-      const settings = settingsResponse.data || {};
       
-      // Wenn "create_new_user" aktiviert ist, kann trotzdem ein Token erstellt werden
-      if (settings.create_new_user) {
+      // Rest der Funktion bleibt gleich
+      const user = await findUserByEmail(email);
+      
+      // Wenn der Benutzer existiert, ist alles in Ordnung
+      if (user) {
         setEmailValidationStatus({
           valid: true,
-          message: 'Neuer Benutzer wird beim Login erstellt.'
+          message: 'Benutzer gefunden. Token kann erstellt werden.'
         });
         return true;
       } else {
@@ -1900,7 +1943,7 @@ const TokensPage = () => {
                   value={emailToCreate}
                   required
                   aria-label="E-Mail-Adresse"
-                  error={emailValidationStatus && !emailValidationStatus.valid}
+                  error={emailValidationStatus && !emailValidationStatus.valid ? emailValidationStatus.message : undefined}
                 />
                 {emailValidationStatus && emailValidationStatus.message && (
                   <Field.Hint>{emailValidationStatus.message}</Field.Hint>

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.14",
+  "version": "4.0.16",
   "keywords": [],
   "type": "commonjs",
   "exports": {

package/server/src/controllers/tokens.js

@@ -103,13 +103,17 @@ module.exports = {
         select: ['id', 'username', 'email'],
       });
 
-      // If user doesn't exist and create_new_user is not enabled, return error
-      if (!user && !settings.create_new_user) {
+      // Verwende den richtigen Einstellungsnamen: createUserIfNotExists anstatt create_new_user
+      // Prüfe sowohl auf den neuen als auch auf den alten Namen für Abwärtskompatibilität
+      const canCreateUser = settings.createUserIfNotExists || settings.create_new_user;
+
+      // If user doesn't exist and automatic creation is not enabled, return error
+      if (!user && !canCreateUser) {
         return ctx.badRequest('User does not exist and automatic user creation is disabled');
       }
 
       // If user doesn't exist, create a new one
-      if (!user && settings.create_new_user) {
+      if (!user && canCreateUser) {
         // Generate a random username based on the email
         const username = email.split('@')[0] + Math.floor(Math.random() * 10000);
         
@@ -426,22 +430,60 @@ module.exports = {
         return ctx.badRequest('Email is required');
       }
 
-      // Find the user
+      // Überprüfe, ob die Plugin-Einstellungen das Erstellen neuer Benutzer erlauben
+      const pluginStore = strapi.store({
+        environment: '',
+        type: 'plugin',
+        name: 'magic-link',
+      });
+      
+      const settings = await pluginStore.get({ key: 'settings' });
+      
+      // Find the user - Entferne UUID aus der Abfrage, damit es in Strapi v5 funktioniert
       const user = await strapi.db.query('plugin::users-permissions.user').findOne({
         where: { email },
-        select: ['id', 'username', 'email', 'confirmed', 'blocked', 'documentId', 'UUID'],
+        select: ['id', 'username', 'email', 'confirmed', 'blocked', 'documentId'],
       });
 
       if (!user) {
-        return ctx.notFound('User not found');
+        // Mit createUserIfNotExists-Option kann die API weiterhin true zurückgeben
+        if (settings && settings.createUserIfNotExists) {
+          return { 
+            exists: false, 
+            canBeCreated: true,
+            autoCreationEnabled: true
+          };
+        }
+        
+        return {
+          exists: false,
+          canBeCreated: false,
+          autoCreationEnabled: false
+        };
       }
 
-      return user;
+      // Sicheres Benutzerobjekt ohne sensible Daten
+      return {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        documentId: user.documentId || null,
+        exists: true
+      };
     } catch (error) {
+      console.error("Error finding user by email:", error);
       ctx.throw(500, error);
     }
   },
 
+  /**
+   * Validiert eine E-Mail (Alias für Frontend-Aufrufe)
+   * @param {Object} ctx - The request context
+   */
+  async validateEmail(ctx) {
+    return this.findUserByEmail(ctx);
+  },
+
   /**
    * Ban an IP address
    * @param {Object} ctx - The request context
@@ -589,7 +631,8 @@ module.exports = {
       let configPoints = 0;
       
       // Ist das Auto-Create-User Feature deaktiviert? (sicherer)
-      if (settings.create_new_user === false) configPoints += 10;
+      // Prüfe sowohl auf den neuen als auch auf den alten Namen für Abwärtskompatibilität
+      if (settings.createUserIfNotExists === false && settings.create_new_user === false) configPoints += 10;
       
       // Ist das Email-Send Feature aktiviert? (sicherer)
       if (settings.enabled === true) configPoints += 5;

package/server/src/routes/admin.js

@@ -50,6 +50,14 @@ module.exports = {
         policies: [],
       },
     },
+    {
+      method: 'GET',
+      path: '/validate-email',
+      handler: 'tokens.validateEmail',
+      config: {
+        policies: [],
+      },
+    },
     {
       method: 'POST',
       path: '/tokens/:id/block',

package/server/src/services/magic-link.js

@@ -62,16 +62,31 @@ module.exports = ({ strapi }) => ({
   async user(email, username) {
     const settings = await this.settings();
     const createUserIfNotExists = settings.createUserIfNotExists;
+    
+    // --- DEBUG LOGGING START ---
+    strapi.log.info(`[MagicLink Service - user function] Checking user: ${email || username}`);
+    strapi.log.info(`[MagicLink Service - user function] createUserIfNotExists setting value: ${createUserIfNotExists} (Type: ${typeof createUserIfNotExists})`);
+    // --- DEBUG LOGGING END ---
 
     const user = await strapi.query('plugin::users-permissions.user').findOne({
       where: email ? { email } : { username },
     });
+    
+    // --- DEBUG LOGGING START ---
+    strapi.log.info(`[MagicLink Service - user function] User found: ${!!user}`);
+    // --- DEBUG LOGGING END ---
 
     if (!user && !createUserIfNotExists) {
-      throw new Error('User not found');
+      // --- DEBUG LOGGING START ---
+      strapi.log.warn(`[MagicLink Service - user function] User not found AND createUserIfNotExists is false. Throwing error.`);
+      // --- DEBUG LOGGING END ---
+      throw new Error('User not found and auto-creation disabled.'); // Slightly more specific error
     }
 
     if (!user && createUserIfNotExists) {
+      // --- DEBUG LOGGING START ---
+      strapi.log.info(`[MagicLink Service - user function] User not found BUT createUserIfNotExists is true. Creating user...`);
+      // --- DEBUG LOGGING END ---
       const newUser = await this.createUser({
         email,
         username: username || email.split('@')[0],