@programisto/edrm-storage 0.3.1

package/README.md

@@ -0,0 +1,135 @@
+# Endurance Template
+
+## Overview
+
+The Endurance Framework is a highly modular and scalable Node.js project template built on Express.js. It is designed to dynamically load and manage independent modules, making it extremely easy to develop, extend, and maintain web applications. The goal is to create a library of ready-made modules (e.g., login, user management, etc.) that can be easily integrated into any project.
+
+## Features
+
+- **Dynamic Module Loading**: Easily add new modules with their own models and routes, and they will be automatically loaded and exposed by the application.
+- **Express.js**: Fast, unopinionated, minimalist web framework for Node.js.
+- **Modular Structure**: Each module is independent, promoting separation of concerns and better maintainability.
+- **Modules marketplace**: Uses npm packages starting with "EDRM-" to quickly add features to your API. 
+- **Lib assets**: Include everything your need to start creating a robust API : events management, CRON, swagger, API versioning, webhooks etc.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js (v20.x)
+- MongoDB (optional for session management and data management)
+
+### Installation
+
+1. Install our CLI:
+
+    ```sh
+    npm install -g endurance
+    ```
+
+2. Create a project folder and create a new project:
+
+    ```sh
+    mkdir newproject
+    cd newproject
+
+    endurance new
+    ```
+
+### Usage
+
+1. **Start the application**:
+
+    For development:
+
+    ```sh
+    npm start
+    ```
+
+    For production:
+
+    ```sh
+    npm run prod
+    ```
+
+2. **Add a new module**:
+
+    To add a new module, create a new folder under the `modules` directory. Each module should contain its own models and routes.
+
+    Example structure for a new module:
+
+    ```
+    modules/
+      your-module/
+        models/
+          YourModel.js
+        routes/
+          yourModule.router.js
+    ```
+
+3. **Dynamic Module Loading**:
+
+    The application will automatically load and expose the routes and models from any new module added to the `modules` directory. There is no need for additional configuration.
+
+### Example
+
+Here is an example of how to add a simple "login" module:
+
+1. **Create the module structure**:
+
+    ```
+    modules/
+      login/
+        models/
+          User.js
+        routes/
+          login.router.js
+    ```
+
+2. **Define the model (`User.js`)**:
+
+    ```javascript
+    const mongoose = require('mongoose');
+
+    const UserSchema = new mongoose.Schema({
+      username: { type: String, required: true },
+      password: { type: String, required: true }
+    });
+
+    module.exports = mongoose.model('User', UserSchema);
+    ```
+
+3. **Define the route (`login.router.js`)**:
+
+    ```javascript
+    const router = require('endurance-core/lib/router')();
+
+    router.post('/login', (req, res) => {
+      // Your login logic here
+      res.send('Login route');
+    });
+
+    module.exports = router;
+    ```
+
+### Testing
+
+Run tests using Mocha and Supertest:
+
+    ```sh
+    npm test
+    ```
+
+### Roadmap
+
+- **Library of Modules**: Develop a library of ready-made modules (e.g., login, user management) for easy integration.
+- **Enhanced Documentation**: Provide detailed documentation and examples for each module.
+- **Community Contributions**: Encourage community contributions to expand the module library.
+
+## Contributing
+
+We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING.md) for more details.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

package/dist/bin/www.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/www.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const localAppPath = path.join(__dirname, '../lib/app.js');
+if (fs.existsSync(localAppPath)) {
+    await import(localAppPath);
+}
+else {
+    await import('@programisto/endurance-core');
+}

package/dist/modules/edrm-exams/lib/openai/correctQuestion.txt

@@ -0,0 +1,9 @@
+Question : ${instruction}
+Type de question : ${questionType} 
+- si MCQ les réponses possibles étaient : ${possibleResponses}
+
+Réponse du candidat à corriger :
+--------------------------------
+ ${response}
+--------------------------------
+Score à donner : De 0 point (tout faux ou réponse vide) à ${maxScore} points (réponse correcte), avec un commentaire de correction

package/dist/modules/edrm-exams/lib/openai/createQuestion.txt

@@ -0,0 +1,6 @@
+Métier ciblé : ${job}
+Catégorie de la question : ${category} niveau ${expertiseLevel} 
+Type de question : ${questionType}
+Format : json
+
+Voici la liste des questions déjà présentes dans le test (pour éviter les doublons) : ${otherQuestions}

package/dist/modules/edrm-exams/lib/openai.d.ts

@@ -0,0 +1,37 @@
+interface CreateQuestionParams {
+    job: string;
+    seniority: string;
+    questionType: string;
+    category: string;
+    expertiseLevel: string;
+    otherQuestions: string;
+}
+interface CorrectQuestionParams {
+    question: {
+        _id: string;
+        instruction: string;
+        maxScore: number;
+        possibleResponses: Array<{
+            possibleResponse: string;
+            valid: boolean;
+        }>;
+        questionType: string;
+    };
+    result: {
+        responses: Array<{
+            questionId: string;
+            response: string;
+        }>;
+    };
+}
+interface ContextBuilder {
+    createQuestion: (params: CreateQuestionParams) => Promise<Record<string, string>>;
+    correctQuestion: (params: CorrectQuestionParams) => Promise<{
+        instruction: string;
+        response: string;
+        maxScore: number;
+    }>;
+}
+export declare function generateLiveMessage(messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
+export declare function generateLiveMessageAssistant(assistantId: string, messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
+export {};

package/dist/modules/edrm-exams/lib/openai.js

@@ -0,0 +1,135 @@
+import OpenAI from 'openai';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const openai = new OpenAI({
+    apiKey: process.env.OPENAI_API_KEY
+});
+const contextBuilder = {
+    async createQuestion({ job, seniority, questionType, category, expertiseLevel, otherQuestions }) {
+        const context = {
+            job,
+            seniority,
+            questionType,
+            category,
+            expertiseLevel,
+            otherQuestions
+        };
+        return context;
+    },
+    async correctQuestion({ question, result }) {
+        let response = '';
+        for (let i = 0; i < result.responses.length; i++) {
+            if (result.responses[i].questionId === question._id) {
+                response = result.responses[i].response;
+                break;
+            }
+        }
+        const instruction = question.instruction;
+        const maxScore = question.maxScore;
+        const questionType = question.questionType;
+        const possibleResponses = question.possibleResponses.map((response, index) => `réponse ${index + 1} = "${response.possibleResponse}" (${response.valid ? 'correcte' : 'incorrecte'})`).join('\n');
+        const context = {
+            instruction,
+            response,
+            maxScore,
+            questionType,
+            possibleResponses
+        };
+        return context;
+    }
+};
+export async function generateLiveMessage(messageType, params, json) {
+    const MAX_RETRY = 2;
+    let retryCount = 0;
+    const context = await contextBuilder[messageType](params);
+    const text = fs.readFileSync(path.join(__dirname, 'openai', `${messageType}.txt`), 'utf8');
+    const message = text.replace(/\${(.*?)}/g, (_, v) => context[v]);
+    while (retryCount <= MAX_RETRY) {
+        try {
+            const openAIParams = {
+                model: 'gpt-4-1106-preview',
+                temperature: 0.7,
+                messages: [{ role: 'system', content: message }]
+            };
+            if (json) {
+                openAIParams.response_format = { type: 'json_object' };
+            }
+            const result = await openai.chat.completions.create(openAIParams);
+            const content = result.choices[0].message.content;
+            if (!content) {
+                throw new Error('No content in response');
+            }
+            return removeQuotes(content);
+        }
+        catch (error) {
+            retryCount++;
+            console.log(error);
+            if (retryCount > MAX_RETRY) {
+                return 'Brain freezed, I cannot generate a live message right now.';
+            }
+        }
+    }
+    return 'Brain freezed, I cannot generate a live message right now.';
+}
+export async function generateLiveMessageAssistant(assistantId, messageType, params, json) {
+    const MAX_RETRY = 2;
+    let retryCount = 0;
+    // Construire le contexte pour le message
+    const context = await contextBuilder[messageType](params);
+    const text = fs.readFileSync(path.join(__dirname, 'openai', `${messageType}.txt`), 'utf8');
+    const message = text.replace(/\${(.*?)}/g, (_, v) => context[v]);
+    while (retryCount <= MAX_RETRY) {
+        try {
+            // Créer un thread avec l'assistant
+            const thread = await openai.beta.threads.create();
+            // Ajouter le message avec le contexte
+            await openai.beta.threads.messages.create(thread.id, {
+                role: 'user',
+                content: message
+            });
+            // Exécuter l'assistant
+            const run = await openai.beta.threads.runs.create(thread.id, {
+                assistant_id: assistantId
+            });
+            // Attendre que l'exécution soit terminée
+            let runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            while (runStatus.status === 'in_progress' || runStatus.status === 'queued') {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            }
+            if (runStatus.status === 'failed') {
+                throw new Error('Assistant execution failed');
+            }
+            // Récupérer les messages de réponse
+            const messages = await openai.beta.threads.messages.list(thread.id);
+            const lastMessage = messages.data[0]; // Le premier message est le plus récent
+            if (!lastMessage || !lastMessage.content || lastMessage.content.length === 0) {
+                throw new Error('No content in response');
+            }
+            const content = lastMessage.content[0];
+            if (content.type === 'text') {
+                return removeQuotes(content.text.value);
+            }
+            else {
+                throw new Error('Unexpected content type');
+            }
+        }
+        catch (error) {
+            retryCount++;
+            console.log(error);
+            if (retryCount > MAX_RETRY) {
+                return 'Brain freezed, I cannot generate a live message right now.';
+            }
+        }
+    }
+    return 'Brain freezed, I cannot generate a live message right now.';
+}
+function removeQuotes(str) {
+    if (str.startsWith('"') && str.endsWith('"')) {
+        return str.substring(1, str.length - 1);
+    }
+    return str;
+}

package/dist/modules/edrm-exams/listeners/correct.listener.d.ts

@@ -0,0 +1,2 @@
+import { enduranceListener } from '@programisto/endurance-core';
+export default enduranceListener;

package/dist/modules/edrm-exams/listeners/correct.listener.js

@@ -0,0 +1,167 @@
+import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance-core';
+import TestQuestion from '../models/test-question.model.js';
+import { generateLiveMessageAssistant } from '../lib/openai.js';
+import TestResult, { TestState } from '../models/test-result.model.js';
+import CandidateModel from '../models/candidate.model.js';
+import ContactModel from '../models/contact.model.js';
+import TestModel from '../models/test.model.js';
+async function sendDiscordNotification(message) {
+    const discordWebhook = process.env.TEST_CORRECTION_DISCORD_WEBHOOKS;
+    if (discordWebhook) {
+        try {
+            await fetch(discordWebhook, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    content: message,
+                }),
+            });
+        }
+        catch (error) {
+            console.error('Error sending Discord notification:', error);
+        }
+    }
+}
+async function correctTest(options) {
+    if (!options.testId)
+        throw new Error('TestId is required');
+    if (!options.responses)
+        throw new Error('Responses are required');
+    if (!options.state)
+        throw new Error('State is required');
+    try {
+        // Récupérer le résultat de test
+        const result = await TestResult.findById(options._id);
+        if (!result) {
+            throw new Error('Test result not found');
+        }
+        let finalscore = 0;
+        let maxScore = 0;
+        // Pour chaque réponse enregistrée en base, on cherche la correction correspondante
+        for (const dbResponse of result.responses) {
+            const correction = options.responses.find(r => r.questionId.toString() === dbResponse.questionId.toString());
+            if (!correction)
+                continue;
+            const question = await TestQuestion.findById(dbResponse.questionId);
+            if (!question) {
+                console.error('Question not found', { questionId: dbResponse.questionId });
+                continue;
+            }
+            maxScore += question.maxScore;
+            const scoreResponse = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
+                question: {
+                    _id: question._id.toString(),
+                    instruction: question.instruction,
+                    possibleResponses: question.possibleResponses,
+                    questionType: question.questionType,
+                    maxScore: question.maxScore
+                },
+                result: {
+                    responses: [{
+                            questionId: dbResponse.questionId.toString(),
+                            response: dbResponse.response
+                        }]
+                }
+            }, true);
+            console.log('Correction result:', { scoreResponse });
+            const parsedResult = JSON.parse(scoreResponse);
+            // Valider le score retourné par l'IA
+            let validScore = 0;
+            if (parsedResult.score !== undefined && parsedResult.score !== null) {
+                const score = parseFloat(parsedResult.score.toString());
+                if (!isNaN(score) && isFinite(score) && score >= 0) {
+                    validScore = score;
+                }
+                else {
+                    console.warn('Invalid score returned by AI:', parsedResult.score);
+                }
+            }
+            finalscore += validScore;
+            dbResponse.score = validScore;
+            dbResponse.comment = parsedResult.comment || '';
+        }
+        // S'assurer que finalscore est un nombre valide
+        if (isNaN(finalscore) || !isFinite(finalscore)) {
+            console.warn('Invalid finalscore calculated, setting to 0:', finalscore);
+            finalscore = 0;
+        }
+        // S'assurer que maxScore est un nombre valide
+        if (isNaN(maxScore) || !isFinite(maxScore)) {
+            console.warn('Invalid maxScore calculated, setting to 0:', maxScore);
+            maxScore = 0;
+        }
+        // Mettre à jour le score final et l'état
+        result.score = finalscore;
+        result.state = TestState.Finish;
+        // Forcer la sauvegarde des sous-documents responses
+        result.markModified('responses');
+        // Calculer le pourcentage de score en évitant la division par zéro
+        let scorePercentage = 0;
+        if (maxScore > 0) {
+            scorePercentage = Math.ceil((finalscore / maxScore) * 100);
+        }
+        else if (finalscore > 0) {
+            // Si maxScore est 0 mais qu'il y a un score, on met 100%
+            scorePercentage = 100;
+        }
+        // S'assurer que le score est un nombre valide
+        if (isNaN(scorePercentage) || !isFinite(scorePercentage)) {
+            scorePercentage = 0;
+        }
+        // Sauvegarder les modifications avec findByIdAndUpdate pour éviter les conflits de version
+        await TestResult.findByIdAndUpdate(result._id, {
+            $set: {
+                responses: result.responses,
+                score: finalscore,
+                state: result.state
+            }
+        });
+        const test = await TestModel.findById(result.testId);
+        const candidate = await CandidateModel.findById(result.candidateId);
+        if (candidate) {
+            const contact = await ContactModel.findById(candidate.contact);
+            if (contact) {
+                const testLink = (process.env.TEST_INVITATION_LINK || '') + contact.email;
+                enduranceEmitter.emit(enduranceEventTypes.SEND_EMAIL, {
+                    template: 'test-result',
+                    to: contact.email,
+                    data: {
+                        firstname: contact.firstname,
+                        lastname: contact.lastname,
+                        score: scorePercentage,
+                        testName: test?.title || '',
+                        testLink
+                    }
+                });
+                // Envoyer une notification Discord
+                const discordMessage = `📊 **Nouveau résultat de test**\n` +
+                    `**Candidat:** ${contact.firstname} ${contact.lastname}\n` +
+                    `**Test:** ${test?.title || 'Test inconnu'}\n` +
+                    `**Score:** ${scorePercentage}%\n` +
+                    `**Score brut:** ${finalscore}/${maxScore}`;
+                await sendDiscordNotification(discordMessage);
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.error(`Error correcting test: ${err.message}`, { err });
+        }
+        else {
+            console.error('Unknown error occurred during test correction', { err });
+        }
+        throw err; // Propager l'erreur pour la gestion en amont
+    }
+}
+enduranceListener.createListener(enduranceEventTypes.CORRECT_TEST, (args) => {
+    if (typeof args === 'object' && args !== null) {
+        const options = args;
+        correctTest(options);
+    }
+    else {
+        console.error('Invalid data type received in correct listener', { args });
+    }
+});
+export default enduranceListener;

package/dist/modules/edrm-exams/models/candidate.model.d.ts

@@ -0,0 +1,21 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+import { Types } from 'mongoose';
+export declare enum ExperienceLevel {
+    JUNIOR = "JUNIOR",
+    INTERMEDIATE = "INTERMEDIATE",
+    SENIOR = "SENIOR",
+    EXPERT = "EXPERT"
+}
+declare class Candidate extends EnduranceSchema {
+    contact: Types.ObjectId;
+    experienceLevel: string;
+    yearsOfExperience: number;
+    skills: string[];
+    magicLinkToken?: string;
+    magicLinkExpiresAt?: Date;
+    authToken?: string;
+    authTokenExpiresAt?: Date;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Candidate, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const CandidateModel: import("@typegoose/typegoose").ReturnModelType<typeof Candidate, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default CandidateModel;

package/dist/modules/edrm-exams/models/candidate.model.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
+import { Types } from 'mongoose';
+// Enum pour les niveaux d'expérience
+/* eslint-disable no-unused-vars */
+export var ExperienceLevel;
+(function (ExperienceLevel) {
+    ExperienceLevel["JUNIOR"] = "JUNIOR";
+    ExperienceLevel["INTERMEDIATE"] = "INTERMEDIATE";
+    ExperienceLevel["SENIOR"] = "SENIOR";
+    ExperienceLevel["EXPERT"] = "EXPERT";
+})(ExperienceLevel || (ExperienceLevel = {}));
+/* eslint-enable no-unused-vars */
+let Candidate = class Candidate extends EnduranceSchema {
+    contact;
+    experienceLevel;
+    yearsOfExperience;
+    skills;
+    magicLinkToken;
+    magicLinkExpiresAt;
+    authToken;
+    authTokenExpiresAt;
+    static getModel() {
+        return CandidateModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true, ref: 'Contact' }),
+    __metadata("design:type", Types.ObjectId)
+], Candidate.prototype, "contact", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, enum: ExperienceLevel, default: ExperienceLevel.JUNIOR }),
+    __metadata("design:type", String)
+], Candidate.prototype, "experienceLevel", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, type: Number, default: 0 }),
+    __metadata("design:type", Number)
+], Candidate.prototype, "yearsOfExperience", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [String], required: true }),
+    __metadata("design:type", Array)
+], Candidate.prototype, "skills", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, type: String }),
+    __metadata("design:type", String)
+], Candidate.prototype, "magicLinkToken", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, type: Date }),
+    __metadata("design:type", Date)
+], Candidate.prototype, "magicLinkExpiresAt", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, type: String }),
+    __metadata("design:type", String)
+], Candidate.prototype, "authToken", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, type: Date }),
+    __metadata("design:type", Date)
+], Candidate.prototype, "authTokenExpiresAt", void 0);
+Candidate = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], Candidate);
+const CandidateModel = EnduranceModelType.getModelForClass(Candidate);
+export default CandidateModel;

package/dist/modules/edrm-exams/models/candidate.models.d.ts

@@ -0,0 +1,21 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+import { Types } from 'mongoose';
+export declare enum ExperienceLevel {
+    JUNIOR = "JUNIOR",
+    INTERMEDIATE = "INTERMEDIATE",
+    SENIOR = "SENIOR",
+    EXPERT = "EXPERT"
+}
+declare class Candidate extends EnduranceSchema {
+    contact: Types.ObjectId;
+    experienceLevel: string;
+    yearsOfExperience: number;
+    skills: string[];
+    magicLinkToken?: string;
+    magicLinkExpiresAt?: Date;
+    authToken?: string;
+    authTokenExpiresAt?: Date;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Candidate, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const CandidateModel: import("@typegoose/typegoose").ReturnModelType<typeof Candidate, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default CandidateModel;