Spaces:

Ymc3013
/

user_save

Sleeping

App Files Files Community

Ymc3013 commited on Jun 25

Commit

97abfa4

verified ·

1 Parent(s): 1d4002d

Update serveur.js

Browse files

Files changed (1) hide show

serveur.js +272 -97

serveur.js CHANGED Viewed

@@ -1,105 +1,280 @@
-const express = require('express');
-const { WebSocketServer } = require('ws');
-const http = require('http');
-const axios = require('axios');
-const fs = require('fs');
-const path = require('path');
-// --- INTERCONNEXION AVEC TON LOGICIEL DE MAJ ---
-const { gererMiseAJour } = require('./serveur_maj.js');
-// --- CONFIGURATION GOOGLE (ID CLIENT ENREGISTRÉ) ---
-const GOOGLE_CLIENT_ID = '411319004349-2dqnskihu1jf5vkptfp7n6p0i6bcifll.apps.googleusercontent.com';
-// /!\ PENSE À METTRE TON SECRET CLIENT GOOGLE ICI /!\
-const GOOGLE_CLIENT_SECRET = 'TON_SECRET_CLIENT_A_COPIER_DE_GOOGLE';
-const PORT = process.env.PORT || 7860;
-const DOSSIER_USER = path.join(__dirname, 'user');
-if (!fs.existsSync(DOSSIER_USER)) {
-    fs.mkdirSync(DOSSIER_USER);
-}
-const app = express();
-const server = http.createServer(app);
-// Route HTTP appelée par Google après authentification
-app.get('/auth/google/callback', async (req, res) => {
-    const code = req.query.code;
-    if (!code) return res.status(400).send("Code de validation manquant.");
-    try {
-        // Échange du code temporaire contre un jeton d'accès
-        const tokenResponse = await axios.post('https://oauth2.googleapis.com/token', {
-            code: code,
-            client_id: GOOGLE_CLIENT_ID,
-            client_secret: GOOGLE_CLIENT_SECRET,
-            redirect_uri: 'https://ymc3013-user-save.hf.space/auth/google/callback',
-            grant_type: 'authorization_code'
-        });
-        const { access_token } = tokenResponse.data;
-        // Récupération des infos du profil utilisateur
-        const userResponse = await axios.get('https://www.googleapis.com/oauth2/v2/userinfo', {
-            headers: { Authorization: `Bearer ${access_token}` }
-        });
-        const profilGoogle = userResponse.data;
-        console.log(`[GOOGLE AUTH SUCCESS] Connexion de : ${profilGoogle.email}`);
-        // Sauvegarde automatique dans le dossier user
-        const contenuFichier = `id: ${profilGoogle.id}\npseudo: ${profilGoogle.name}\nemail: ${profilGoogle.email}`;
-        const nomFichier = `${profilGoogle.email.replace(/[^a-zA-Z0-9@.]/g, "_")}.txt`;
-        fs.writeFileSync(path.join(DOSSIER_USER, nomFichier), contenuFichier, 'utf8');
-        // Page HTML renvoyée dans la popup
-        res.send(`
-            <html>
-            <body style="font-family: sans-serif; text-align: center; padding-top: 50px; background: #1e1e2e; color: white;">
-                <h2>Connexion Google réussie !</h2>
-                <p>Bienvenue ${profilGoogle.name}. Tu peux fermer cette fenêtre pour retourner au jeu.</p>
-                <script>
-                    window.opener.postMessage(${JSON.stringify({
-                        accountName: profilGoogle.email,
-                        fullName: profilGoogle.name,
-                        profilePicture: profilGoogle.picture,
-                        userId: profilGoogle.id,
-                        emailVerified: profilGoogle.verified_email
-                    })}, "*");
-                </script>
-            </body>
-            </html>
-        `);
-    } catch (error) {
-        console.error("Erreur Google Auth:", error.response ? error.response.data : error.message);
-        res.status(500).send("Une erreur est survenue durant l'authentification.");
     }
-});
-// Initialisation du serveur WebSocket
-const wss = new WebSocketServer({ server });
-wss.on('connection', (ws) => {
-    console.log("[CONNEXION] Un utilisateur a rejoint le serveur.");
-    ws.on('message', (message) => {
-        const texteRecu = message.toString();
-        const estUneMaj = gererMiseAJour(texteRecu, ws);
-        if (estUneMaj) return;
-        // Diffusion du chat standard
-        wss.clients.forEach((client) => {
-            if (client.readyState === 1) {
-                client.send(texteRecu);
             }
-        });
-    });
-});
-server.listen(PORT, '0.0.0.0', () => {
-    console.log(`=== SERVEUR ACTIF SUR LE PORT ${PORT} ===`);
-});

+// Name: WebSocket avec Authentification
+// ID: gsaWebsocket
+// Description: Connect to WebSocket servers and handle user file verification with boolean status.
+// By: RedMan13 & Custom Auth
+// License: MIT
+(function (Scratch) {
+  "use strict";
+  if (!Scratch.extensions.unsandboxed) {
+    throw new Error("can not load outside unsandboxed mode");
+  }
+  const blobToDataURL = (blob) =>
+    new Promise((resolve, reject) => {
+      const fr = new FileReader();
+      fr.onload = () => resolve(fr.result);
+      fr.onerror = () =>
+        reject(new Error(`Failed to read as data URL: ${fr.error}`));
+      fr.readAsDataURL(blob);
+    });
+  /* ------- BLOCKS -------- */
+  const { BlockType, Cast, ArgumentType } = Scratch;
+  const vm = Scratch.vm;
+  const runtime = vm.runtime;
+  class WebSocketExtension {
+    constructor() {
+      /** @type {Record<string, WebSocketInfo>} */
+      this.instances = {};
+      runtime.on("targetWasRemoved", (target) => {
+        const instance = this.instances[target.id];
+        if (instance) {
+          instance.destroyed = true;
+          if (instance.websocket) {
+            instance.websocket.close();
+          }
+          delete this.instances[target.id];
+        }
+      });
+    }
+    getInfo() {
+      return {
+        id: "gsaWebsocket",
+        name: "WebSocket Auth",
+        color1: "#307eff",
+        color2: "#2c5eb0",
+        blocks: [
+          {
+            opcode: "newInstance",
+            blockType: BlockType.COMMAND,
+            arguments: {
+              URL: {
+                type: ArgumentType.STRING,
+                defaultValue: "wss://ymc3013-user-save.hf.space",
+              },
+            },
+            text: "connect to [URL]",
+          },
+          "---",
+          {
+            opcode: "enregistrerUtilisateur",
+            blockType: BlockType.COMMAND,
+            arguments: {
+              PSEUDO: { type: ArgumentType.STRING, defaultValue: "Scratcher" },
+              EMAIL: { type: ArgumentType.STRING, defaultValue: "exemple@gmail.com" },
+            },
+            text: "enregistrer l'utilisateur avec le pseudo [PSEUDO] et l'email [EMAIL]",
+          },
+          {
+            opcode: "verifierUtilisateur",
+            blockType: BlockType.COMMAND,
+            arguments: {
+              PSEUDO: { type: ArgumentType.STRING, defaultValue: "Scratcher" },
+              EMAIL: { type: ArgumentType.STRING, defaultValue: "exemple@gmail.com" },
+            },
+            text: "vérifier l'utilisateur avec le pseudo [PSEUDO] et l'email [EMAIL]",
+          },
+          "---",
+          // --- LES DEUX NOUVEAUX BLOCS DE STATUT ---
+          {
+            opcode: "estVerificationValide",
+            blockType: BlockType.BOOLEAN,
+            text: "dernière vérification valide ?",
+            disableMonitor: false,
+          },
+          {
+            opcode: "messageVerification",
+            blockType: BlockType.REPORTER,
+            text: "statut de la dernière vérification",
+            disableMonitor: false,
+          },
+          "---",
+          {
+            opcode: "onOpen",
+            blockType: BlockType.EVENT,
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            text: "when connected",
+          },
+          {
+            opcode: "isConnected",
+            blockType: BlockType.BOOLEAN,
+            text: "is connected?",
+            disableMonitor: true,
+          },
+          "---",
+          {
+            opcode: "onMessage",
+            blockType: BlockType.EVENT,
+            isEdgeActivated: false,
+            shouldRestartExistingThreads: true,
+            text: "when message received",
+          },
+          {
+            opcode: "messageData",
+            blockType: BlockType.REPORTER,
+            text: "received message data",
+            disableMonitor: true,
+          },
+          "---",
+          {
+            opcode: "closeWithoutReason",
+            blockType: BlockType.COMMAND,
+            text: "close connection",
+          }
+        ],
+      };
     }
+    // --- ENREGISTREMENT ET VÉRIFICATION ---
+    enregistrerUtilisateur(args, utils) {
+      const payload = JSON.stringify({
+        type: "enregistrement",
+        pseudo: Cast.toString(args.PSEUDO),
+        email: Cast.toString(args.EMAIL)
+      });
+      this.sendMessage({ PAYLOAD: payload }, utils);
+    }
+    verifierUtilisateur(args, utils) {
+      const payload = JSON.stringify({
+        type: "comparer",
+        pseudo: Cast.toString(args.PSEUDO),
+        email: Cast.toString(args.EMAIL)
+      });
+      this.sendMessage({ PAYLOAD: payload }, utils);
+    }
+    // --- FONCTIONS DES NOUVEAUX BLOCS BOULÉENS ---
+    estVerificationValide(_, utils) {
+      const instance = this.instances[utils.target.id];
+      if (!instance || instance.verificationValide === undefined) return false;
+      return instance.verificationValide; // Renvoie true ou false
+    }
+    messageVerification(_, utils) {
+      const instance = this.instances[utils.target.id];
+      if (!instance || !instance.verificationMessage) return "";
+      return instance.verificationMessage; // Renvoie le texte ("Infos correctes", etc.)
+    }
+    // --- MOTEUR DE L'EXTENSION ---
+    newInstance(args, util) {
+      const target = util.target;
+      let url = Cast.toString(args.URL);
+      const oldInstance = this.instances[util.target.id];
+      if (oldInstance) {
+        oldInstance.destroyed = true;
+        if (oldInstance.websocket) oldInstance.websocket.close();
+      }
+      const instance = {
+        destroyed: false,
+        errored: false,
+        data: "",
+        websocket: null,
+        messageThreadsRunning: false,
+        connectThreads: [],
+        messageThreads: [],
+        messageQueue: [],
+        sendOnceConnected: [],
+        // Variables pour mémoriser l'état de la connexion utilisateur
+        verificationValide: false,
+        verificationMessage: "Aucune vérification effectuée"
+      };
+      this.instances[util.target.id] = instance;
+      return Scratch.canFetch(url)
+        .then((allowed) => new Promise((resolve) => {
+          if (!allowed) throw new Error("Not allowed");
+          const websocket = new WebSocket(url);
+          instance.websocket = websocket;
+          const beforeExecute = () => {
+            if (instance.messageThreadsRunning) {
+              const stillRunning = instance.messageThreads.some((i) => runtime.isActiveThread(i));
+              if (!stillRunning) {
+                if (instance.messageQueue.length === 0) {
+                  instance.messageThreadsRunning = false;
+                  instance.messageThreads = [];
+                } else {
+                  instance.data = instance.messageQueue.shift();
+                  instance.messageThreads = runtime.startHats("gsaWebsocket_onMessage", null, target);
+                }
+              }
             }
+          };
+          vm.runtime.on("BEFORE_EXECUTE", beforeExecute);
+          websocket.onopen = () => {
+            for (const item of instance.sendOnceConnected) websocket.send(item);
+            instance.sendOnceConnected.length = 0;
+            instance.connectThreads = runtime.startHats("gsaWebsocket_onOpen", null, target);
+            resolve();
+          };
+          websocket.onmessage = async (e) => {
+            if (instance.destroyed) return;
+            let data = e.data;
+            if (data instanceof Blob) data = await blobToDataURL(data);
+            // --- INTERCEPTION DE LA RÉPONSE DE VÉRIFICATION ---
+            try {
+              const json = JSON.parse(data);
+              if (json.type === "reponse_comparer") {
+                instance.verificationValide = json.valide; // true ou false
+                instance.verificationMessage = json.message; // Le message texte
+              }
+            } catch (err) {}
+            if (instance.messageThreadsRunning) {
+              instance.messageQueue.push(data);
+            } else {
+              instance.data = data;
+              instance.messageThreads = runtime.startHats("gsaWebsocket_onMessage", null, target);
+              instance.messageThreadsRunning = true;
+            }
+          };
+        }));
+    }
+    isConnected(_, utils) {
+      const instance = this.instances[utils.target.id];
+      return !!instance && !!instance.websocket && instance.websocket.readyState === WebSocket.OPEN;
+    }
+    messageData(_, utils) {
+      const instance = this.instances[utils.target.id];
+      return instance ? instance.data : "";
+    }
+    sendMessage(args, utils) {
+      const PAYLOAD = Cast.toString(args.PAYLOAD);
+      const instance = this.instances[utils.target.id];
+      if (!instance) return;
+      if (!instance.websocket || instance.websocket.readyState === WebSocket.CONNECTING) {
+        instance.sendOnceConnected.push(PAYLOAD);
+      } else {
+        instance.websocket.send(PAYLOAD);
+      }
+    }
+    closeWithoutReason(_, utils) {
+      const instance = this.instances[utils.target.id];
+      if (!instance) return;
+      instance.destroyed = true;
+      if (instance.websocket) instance.websocket.close();
+    }
+  }
+  Scratch.extensions.register(new WebSocketExtension());
+})(Scratch);