data-primals-engine 1.0.0

package/src/providers.js

@@ -0,0 +1,61 @@
+import {compare} from "bcrypt";
+
+/**
+ * @class UserProvider
+ * Définit le contrat pour toutes les implémentations de fournisseurs d'utilisateurs.
+ * C'est une classe de base abstraite, elle n'est pas destinée à être utilisée directement.
+ */
+export class UserProvider {
+    constructor(engine) {
+        if (this.constructor === UserProvider) {
+            throw new Error("Abstract classes can't be instantiated.");
+        }
+        this.engine = engine;
+    }
+
+    /**
+     * Trouve un utilisateur par son nom d'utilisateur.
+     * @param {string} username - Le nom d'utilisateur à rechercher.
+     * @returns {Promise<object|null>} L'objet utilisateur ou null.
+     */
+    async findUserByUsername(username) {
+        throw new Error("Method 'findUserByUsername()' must be implemented.");
+    }
+
+    /**
+     * Valide le mot de passe d'un utilisateur.
+     * @param {object} user - L'objet utilisateur.
+     * @param {string} password - Le mot de passe à vérifier.
+     * @returns {Promise<boolean>} True si le mot de passe est valide.
+     */
+    async validatePassword(user, password) {
+        throw new Error("Method 'validatePassword()' must be implemented.");
+    }
+
+    /**
+     * Initialise un utilisateur sur la requête (pour les middlewares).
+     * @param {object} req - L'objet requête Express.
+     * @returns {Promise<void>}
+     */
+    async initiateUser(req) {
+        throw new Error("Method 'initiateUser()' must be implemented.");
+    }
+
+    // Ajoutez ici d'autres méthodes nécessaires : findUserById, createUser, etc.
+}
+
+
+export class DefaultUserProvider extends UserProvider {
+
+    async findUserByUsername(username) {
+        return { username: "test", password: "test" };
+    }
+
+    async validatePassword(user, password) {
+        if (!user || !user.password || !password) return false;
+        return await compare(password, user.password);
+    }
+
+    async initiateUser(req) {
+    }
+}

package/src/tutorials.js

@@ -0,0 +1,112 @@
+// Fichier : src/tutorials.js
+
+export const tutorialsConfig = [
+    {
+        id: 'contact-management-basics',
+        name: 'Gestion des contacts : Les bases',
+        description: 'Apprenez les opérations fondamentales : créer et supprimer un contact.',
+        icon: 'FaUserPlus',
+        stages: [
+            {
+                stage: 1,
+                tourName: 'tour-create-contact', // Nom du tour guidé à lancer
+                name: 'Créez votre premier contact',
+                description: 'Ajoutez un nouveau contact avec le prénom "Richard".',
+                completionCondition: { model: 'contact', limit: 1, filter: { "firstName": "Richard" } }
+            },
+            {
+                stage: 2,
+                tourName: 'tour-delete-contact',
+                name: 'Effacez vos traces',
+                description: 'Maintenant, supprimez le contact "Richard" que vous venez de créer.',
+                // La condition pour valider une suppression est de vérifier que le nombre d'éléments correspondants est 0.
+                completionCondition: { model: 'contact', limit: 0, filter: { "firstName": "Richard" } }
+            }
+        ],
+        rewards: {
+            xpBonus: 150,
+            achievement: 'CONTACT_MANAGER_NOVICE',
+            notification: { title: 'Gestionnaire de contacts', message: 'Vous maîtrisez les bases de la gestion de contacts !' }
+        }
+    },
+    {
+        id: 'advanced-permissions',
+        name: 'Permissions & rôles',
+        description: 'Maîtrisez la gestion des droits du bout des doigts !',
+        icon: 'FaUserShield',
+        stages: [
+            {
+                stage: 1,
+                tourName: 'tour-set-permissions',
+                name: 'Gestion des droits utilisateurs',
+                description: 'Trouvez l\'utilisateur "userTuto" et donnez-lui le droit "visitor".',
+                completionCondition: {model: 'user', limit: 1, filter: {"username": "userTuto", "roles": { "$find": {"$eq":["$$this.name","visitor"]}}}}
+            },
+            {
+                stage: 2,
+                tourName: 'tour-create-role',
+                name: 'Créer un nouveau rôle',
+                description: 'Créez un rôle personnalisé nommé "Modérateur".',
+                // Condition : un document dans le modèle 'role' avec le nom 'Modérateur' doit exister.
+                // (On suppose ici l'existence d'un modèle 'role' pour gérer les rôles).
+                completionCondition: { model: 'role', limit: 1, filter: { "name": "moderator" } }
+            },
+            {
+                stage: 3,
+                tourName: 'tour-assign-permission-to-role',
+                name: 'Ajouter une permission au rôle',
+                description: 'Modifiez le rôle "moderator" pour lui ajouter la permission "API_EDIT_DATA_content".',
+                // Condition : le rôle 'Modérateur' doit avoir une permission nommée 'delete_contact'.
+                // (On suppose que le modèle 'role' a un champ 'permissions' qui est un tableau de relations).
+                completionCondition: { model: 'role', limit: 1, filter: { "name": "moderator", "permissions": { "$find": { "$eq": ["$$this.name", "API_EDIT_DATA_content"] } } } }
+            },
+            {
+                stage: 4,
+                tourName: 'tour-assign-role-to-user',
+                name: 'Promouvoir un utilisateur',
+                description: 'Maintenant, assignez votre rôle "moderator" à l\'utilisateur "userTuto".',
+                // Condition : l'utilisateur 'userTuto' doit maintenant aussi avoir le rôle 'Modérateur'.
+                completionCondition: { model: 'user', limit: 1, filter: { "username": "userTuto", "roles": { "$find": { "$eq": ["$$this.name", "moderator"] } } } }
+            }
+        ],
+        rewards: {
+            xpBonus: 500,
+            achievement: 'PERMISSION_ARCHITECT',
+            notification: { title: 'Architecte des Permissions', message: 'Vous savez maintenant comment finement gérer les accès !' }
+        }
+    },
+    {
+        id: 'requests',
+        name: 'Suivi d\'Activité',
+        description: 'Découvrez les succès liés à l\'activité.',
+        icon: 'FaUserShield',
+        stages: [
+            {
+                stage: 1,
+                tourName: null, // Pas de tour guidé, l'action peut se faire n'importe où
+                name: 'Première requête',
+                description: 'Effectuez des actions pour générer 50 requêtes système pour débloquer votre premier succès d\'activité.',
+                completionCondition: {model: 'request', limit: 50, filter: {}}
+            },
+            {
+                stage: 2,
+                tourName: null,
+                name: 'Activité soutenue',
+                description: 'Continuez votre activité et atteignez 250 requêtes pour le prochain palier.',
+                completionCondition: {model: 'request', limit: 250, filter: {}}
+            },
+            {
+                stage: 3,
+                tourName: null,
+                name: 'Expert en requêtes',
+                description: 'Impressionnant ! Atteignez 1000 requêtes pour prouver votre maîtrise.',
+                completionCondition: {model: 'request', limit: 1000, filter: {}}
+            }
+        ],
+        rewards: {
+            xpBonus: 1000,
+            achievement: 'REQUEST_MASTER',
+            notification: { title: 'Maître des Requêtes', message: 'Votre activité sur le réseau est remarquable !' }
+        }
+    }
+];

package/src/user.js

@@ -0,0 +1,17 @@
+import {
+    maxTotalPrivateFilesSizeFree,
+    maxTotalPrivateFilesSizePremium,
+    maxTotalPrivateFilesSizeStandard
+} from "./constants.js";
+
+export const getUserStorageLimit = (user) => {
+    switch (user.userPlan) {
+        case 'premium':
+            return maxTotalPrivateFilesSizePremium;
+        case 'standard':
+            return maxTotalPrivateFilesSizeStandard;
+        case 'free':
+        default:
+            return maxTotalPrivateFilesSizeFree;
+    }
+};

package/src/workers/crypto-worker.js

@@ -0,0 +1,77 @@
+// C:/Dev/hackersonline-engine/server/src/workers/crypto-worker.js
+import { parentPort } from 'worker_threads';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { promisify } from 'node:util';
+import bcrypt from 'bcrypt'; // 1. Importer bcrypt
+
+// --- Fonctions de cryptographie (inchangées) ---
+const pbkdf2Async = promisify(crypto.pbkdf2);
+const algorithm = 'aes-256-cbc';
+const iterations = 100000;
+const keyLength = 32;
+const ivLength = 16;
+
+async function deriveKeyAndIV(password, salt) {
+    const key = await pbkdf2Async(password, salt, iterations, keyLength, 'sha256');
+    return { key };
+}
+
+async function encryptFile(filePath, password) {
+    // ... (fonction inchangée)
+    const salt = crypto.randomBytes(16);
+    const iv = crypto.randomBytes(ivLength);
+    const { key } = await deriveKeyAndIV(password, salt);
+    const fileData = await fs.readFile(filePath);
+    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    const encryptedData = Buffer.concat([cipher.update(fileData), cipher.final()]);
+    await fs.writeFile(filePath, Buffer.concat([salt, iv, encryptedData]));
+}
+
+async function decryptFile(filePath, password) {
+    // ... (fonction inchangée)
+    const fileData = await fs.readFile(filePath);
+    const salt = fileData.slice(0, 16);
+    const iv = fileData.slice(16, 16 + ivLength);
+    const encryptedData = fileData.slice(16 + ivLength);
+    const { key } = await deriveKeyAndIV(password, salt);
+    const decipher = crypto.createDecipheriv(algorithm, key, iv);
+    const decryptedData = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+    await fs.writeFile(filePath, decryptedData);
+}
+// --- Fin des fonctions de cryptographie ---
+
+// 2. Mettre à jour le gestionnaire de messages pour être plus générique et ajouter le cas 'hash'
+parentPort.on('message', async ({ action, payload }) => {
+    try {
+        let result;
+        switch (action) {
+            case 'encrypt':
+                console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+                await encryptFile(payload.filePath, payload.password);
+                parentPort.postMessage({ success: true }); // Pas de données à retourner
+                break;
+
+            case 'decrypt':
+                console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+                await decryptFile(payload.filePath, payload.password);
+                parentPort.postMessage({ success: true }); // Pas de données à retourner
+                break;
+
+            case 'hash':
+                console.log(`[Worker] Received action: hash`);
+                if (!payload.data) throw new Error('Data to hash is missing in payload.');
+                // Le worker gère à la fois la génération du "salt" et le hachage
+                const salt = await bcrypt.genSalt(10);
+                result = await bcrypt.hash(payload.data, salt);
+                parentPort.postMessage({ success: true, data: result }); // On retourne le hash
+                break;
+
+            default:
+                throw new Error(`Unknown crypto action: ${action}`);
+        }
+    } catch (error) {
+        // Envoie l'erreur au thread principal
+        parentPort.postMessage({ success: false, error: error.message });
+    }
+});

package/src/workers/import-export-worker.js

@@ -0,0 +1,36 @@
+import { parentPort } from 'worker_threads';
+import { parse } from 'csv-parse/sync'; // On utilise la version synchrone, c'est ok dans un worker
+
+parentPort.on('message', ({ action, payload }) => {
+    try {
+        let result;
+        switch (action) {
+            case 'parse-json':
+                // Tâche: Parser une chaîne/buffer JSON en objet JS
+                result = JSON.parse(payload.fileContent.toString('utf-8'));
+                break;
+
+            case 'parse-csv':
+                // Tâche: Parser une chaîne/buffer CSV en tableau d'objets JS
+                result = parse(payload.fileContent, {
+                    columns: payload.options.columns,
+                    skip_empty_lines: true,
+                    trim: true,
+                });
+                break;
+
+            case 'stringify-json':
+                // Tâche: Sérialiser un objet/tableau JS en chaîne JSON
+                result = JSON.stringify(payload.data);
+                break;
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+        // Renvoyer le résultat au thread principal
+        parentPort.postMessage({ success: true, data: result });
+    } catch (error) {
+        // Renvoyer l'erreur au thread principal
+        parentPort.postMessage({ success: false, error: error.message });
+    }
+});