@programisto/edrm-exams 0.1.4 → 0.1.5

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,9 @@
+#!/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');
+const coreAppPath = 'endurance-core/dist/lib/app.js';
+fs.existsSync(localAppPath) ? await import(localAppPath) : await import(coreAppPath);

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

@@ -0,0 +1,10 @@
+Tu est un correcteur de question de concours.
+Tu doit donner un score à cette question : ${instruction} dont la réponse donnée par le candidat est : ${response}.
+Il s'agissait d'une question de type ${questionType} (et si la question est de type MCQ alors les réponses possibles étaient les suivantes : ${possibleResponses})
+le score maximum pour cette question est ${maxScore}
+Tu doit donner un score entre 0 et ${maxScore} et un commentaire de correction.
+Tu dois répondre au format JSON : la reponse envoyer doit correspondre exactement à ce model json : 
+{
+    "score": score,
+    "comment": commentaire
+}

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

@@ -0,0 +1,68 @@
+Tu es un assistant qui crée des questions pour un test.
+    créer une question en fonction de du métier : ${job}, du niveau de seniorité : ${seniority}, de la categorie de question : ${category} et le niveau d'expertise de cette categorie : ${expertiseLevel} (allant de 1 à 10, de 1 à 3 = 'beginner', de 3 à 6 = 'intermediate', de 6 à 10 = 'advanced').
+    - la question doit être de type : ${questionType}.
+    - la question doit être dans la langue suivante : Français
+    - voici le model pour une question : 
+    const questionModel = new mongoose.Schema(
+    {
+        instruction:
+        {
+            type: String,
+            required: true
+        },
+        questionType:
+        {
+            type: String,
+            enum: 
+            ["MCQ", "free question", "exercice"],
+            required: true,
+        },
+        maxScore:
+        {
+            type: Number,
+            required: true,
+        },
+        possibleResponses: // only on MCQ (multiple choice responses)
+        {
+            type: 
+            [{
+                possibleResponse:
+                {
+                    type: String,
+                    required: true,
+                },
+                valid:
+                {
+                    type: Boolean,
+                    required: true
+                }
+            }],
+        },
+        time: // in secondes
+        {
+            type: Number,
+            required: true,
+        },
+        textType: //type d'input demandé à l'utilisateur 
+        {
+            type: String,
+            enum:
+            ["text", "code"],
+            required: false
+        }
+    });
+    - toutes les instruction et les réponses doivent toujours être compatible avec LaTeX pour être afficher dans des balises <MathJax>
+        voici un exemple : Voici une formule mathématique : \\( \\frac{a}{b} = c \\)
+    - voici des containtes pour chaque type de question : 
+    - MCQ
+        (il ne peut y avoir qu'une seule réponse juste sur quatre au total) le temps pour ces questions vont de 30 secondes à 1 minute
+    - free question ( ne rien mettre dans possibleResponses)
+        le temps pour ces questions vont de 30 secondes à 5 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
+    - exercice ( ne rien mettre dans possibleResponses )
+        le temps pour ces questions vont de 3 à 20 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
+    - les instruction et la difficulté doivent être en rapport avec targetJob et seniorityLevel de ${test}
+    - le temps pour répondre à la question dans time doit laisser le temps aux utilisateur d'y répondre, sans non plus lui laisser trop de temps pour qu'il triche (surtout sur les QCM).
+    - le format de la réponses doit être en json avec seulement les elements présent dans le model ci dessus et pas besoin d'ajouter d"_id".
+    - si la réponse attendue à une question de type free question ou exercice est un bout de code, alors remplit textType en "code", sinon laisse "text"
+
+    Pour ne pas faire de doublon, voici la liste des questions déjà présentes dans le test : ${otherQuestions}

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

@@ -0,0 +1,36 @@
+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 {};

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

@@ -0,0 +1,82 @@
+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}`).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.';
+}
+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 'endurance-core';
+export default enduranceListener;

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

@@ -0,0 +1,85 @@
+import { enduranceListener, enduranceEventTypes } from 'endurance-core';
+import TestQuestion from '../models/test-question.model.js';
+import { generateLiveMessage } from '../lib/openai.js';
+import TestResult, { TestState } from '../models/test-result.model.js';
+async function correctTest(options) {
+    console.log('Correcting test', { 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;
+        // 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;
+            }
+            const scoreResponse = await generateLiveMessage('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);
+            finalscore += parsedResult.score;
+            dbResponse.score = parsedResult.score;
+            dbResponse.comment = parsedResult.comment || '';
+        }
+        // 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');
+        // Sauvegarder les modifications avec findByIdAndUpdate pour éviter les conflits de version
+        await TestResult.findByIdAndUpdate(result._id, {
+            $set: {
+                responses: result.responses,
+                score: result.score,
+                state: result.state
+            }
+        });
+        console.log('Test correction completed and saved', { finalScore: finalscore });
+    }
+    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.models.d.ts

@@ -0,0 +1,13 @@
+import { EnduranceSchema } from 'endurance-core';
+declare class Candidate extends EnduranceSchema {
+    firstName: string;
+    lastName: string;
+    email: 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.models.js

@@ -0,0 +1,59 @@
+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 'endurance-core';
+let Candidate = class Candidate extends EnduranceSchema {
+    firstName;
+    lastName;
+    email;
+    magicLinkToken;
+    magicLinkExpiresAt;
+    authToken;
+    authTokenExpiresAt;
+    static getModel() {
+        return CandidateModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Candidate.prototype, "firstName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Candidate.prototype, "lastName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, unique: true }),
+    __metadata("design:type", String)
+], Candidate.prototype, "email", 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/company.model.d.ts

@@ -0,0 +1,8 @@
+import { EnduranceSchema } from 'endurance-core';
+declare class Company extends EnduranceSchema {
+    name: string;
+    logo: string;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Company, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const CompanyModel: import("@typegoose/typegoose").ReturnModelType<typeof Company, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default CompanyModel;

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

@@ -0,0 +1,34 @@
+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 'endurance-core';
+let Company = class Company extends EnduranceSchema {
+    name;
+    logo;
+    static getModel() {
+        return CompanyModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Company.prototype, "name", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Company.prototype, "logo", void 0);
+Company = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], Company);
+const CompanyModel = EnduranceModelType.getModelForClass(Company);
+export default CompanyModel;

package/dist/modules/edrm-exams/models/test-category.models.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceSchema } from 'endurance-core';
+declare class TestCategory extends EnduranceSchema {
+    name: string;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestCategory, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const TestCategoryModel: import("@typegoose/typegoose").ReturnModelType<typeof TestCategory, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default TestCategoryModel;

package/dist/modules/edrm-exams/models/test-category.models.js

@@ -0,0 +1,29 @@
+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 'endurance-core';
+let TestCategory = class TestCategory extends EnduranceSchema {
+    name;
+    static getModel() {
+        return TestCategoryModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], TestCategory.prototype, "name", void 0);
+TestCategory = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], TestCategory);
+const TestCategoryModel = EnduranceModelType.getModelForClass(TestCategory);
+export default TestCategoryModel;

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

@@ -0,0 +1,25 @@
+import { EnduranceSchema } from 'endurance-core';
+declare enum QuestionType {
+    MCQ = "MCQ",
+    FreeQuestion = "free question",
+    Exercise = "exercice"
+}
+interface PossibleResponse {
+    possibleResponse: string;
+    valid: boolean;
+}
+declare enum TextType {
+    Text = "text",
+    Code = "code"
+}
+declare class TestQuestion extends EnduranceSchema {
+    questionType: QuestionType;
+    instruction: string;
+    maxScore: number;
+    possibleResponses: PossibleResponse[];
+    time: number;
+    textType: TextType;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const TestQuestionModel: import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default TestQuestionModel;