@programisto/edrm-exams 0.1.4 → 0.1.6

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

@@ -0,0 +1,70 @@
+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';
+var QuestionType;
+(function (QuestionType) {
+    // eslint-disable-next-line no-unused-vars
+    QuestionType["MCQ"] = "MCQ";
+    // eslint-disable-next-line no-unused-vars
+    QuestionType["FreeQuestion"] = "free question";
+    // eslint-disable-next-line no-unused-vars
+    QuestionType["Exercise"] = "exercice";
+})(QuestionType || (QuestionType = {}));
+var TextType;
+(function (TextType) {
+    // eslint-disable-next-line no-unused-vars
+    TextType["Text"] = "text";
+    // eslint-disable-next-line no-unused-vars
+    TextType["Code"] = "code";
+})(TextType || (TextType = {}));
+let TestQuestion = class TestQuestion extends EnduranceSchema {
+    questionType;
+    instruction;
+    maxScore;
+    possibleResponses;
+    time;
+    textType;
+    static getModel() {
+        return TestQuestionModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: QuestionType }),
+    __metadata("design:type", String)
+], TestQuestion.prototype, "questionType", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], TestQuestion.prototype, "instruction", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", Number)
+], TestQuestion.prototype, "maxScore", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Object], required: false }),
+    __metadata("design:type", Array)
+], TestQuestion.prototype, "possibleResponses", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", Number)
+], TestQuestion.prototype, "time", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false, enum: TextType, default: TextType.Text }),
+    __metadata("design:type", String)
+], TestQuestion.prototype, "textType", void 0);
+TestQuestion = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], TestQuestion);
+const TestQuestionModel = EnduranceModelType.getModelForClass(TestQuestion);
+export default TestQuestionModel;

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

@@ -0,0 +1,26 @@
+import { EnduranceSchema, ObjectId } from '@programisto/endurance-core';
+import Test from './test.model.js';
+import User from './user.model.js';
+export declare enum TestState {
+    Pending = "pending",
+    InProgress = "inProgress",
+    Finish = "finish"
+}
+interface Response {
+    questionId: ObjectId;
+    response: string;
+    score?: number;
+    comment?: string;
+}
+declare class TestResult extends EnduranceSchema {
+    testId: typeof Test;
+    candidateId: typeof User;
+    state: TestState;
+    responses: Response[];
+    score?: number;
+    startTime?: Date;
+    endTime?: Date;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestResult, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+}
+declare const TestResultModel: import("@typegoose/typegoose").ReturnModelType<typeof TestResult, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+export default TestResultModel;

package/dist/modules/edrm-exams/models/test-result.model.js

@@ -0,0 +1,70 @@
+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 Test from './test.model.js';
+import User from './user.model.js';
+export var TestState;
+(function (TestState) {
+    // eslint-disable-next-line no-unused-vars
+    TestState["Pending"] = "pending";
+    // eslint-disable-next-line no-unused-vars
+    TestState["InProgress"] = "inProgress";
+    // eslint-disable-next-line no-unused-vars
+    TestState["Finish"] = "finish";
+})(TestState || (TestState = {}));
+let TestResult = class TestResult extends EnduranceSchema {
+    testId;
+    candidateId;
+    state;
+    responses;
+    score;
+    startTime;
+    endTime;
+    static getModel() {
+        return TestResultModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ ref: () => Test, required: true }),
+    __metadata("design:type", Object)
+], TestResult.prototype, "testId", void 0);
+__decorate([
+    EnduranceModelType.prop({ ref: () => User, required: true }),
+    __metadata("design:type", Object)
+], TestResult.prototype, "candidateId", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: TestState, default: TestState.Pending }),
+    __metadata("design:type", String)
+], TestResult.prototype, "state", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Object], required: true }),
+    __metadata("design:type", Array)
+], TestResult.prototype, "responses", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", Number)
+], TestResult.prototype, "score", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", Date)
+], TestResult.prototype, "startTime", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", Date)
+], TestResult.prototype, "endTime", void 0);
+TestResult = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], TestResult);
+const TestResultModel = EnduranceModelType.getModelForClass(TestResult);
+export default TestResultModel;

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

@@ -0,0 +1,52 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+import Company from './company.model.js';
+import TestQuestion from './test-question.model.js';
+import TestCategory from './test-category.models.js';
+import User from './user.model.js';
+declare enum TestState {
+    Draft = "draft",
+    Published = "published",
+    Archived = "archived"
+}
+declare enum JobType {
+    FrontEnd = "front-end",
+    BackEnd = "back-end",
+    Fullstack = "fullstack",
+    DevOps = "devops",
+    Data = "data"
+}
+declare enum SeniorityLevel {
+    Student = "student",
+    Junior = "junior",
+    Intermediate = "intermediate",
+    Senior = "senior"
+}
+declare enum ExpertiseLevel {
+    Beginner = "beginner",
+    Intermediate = "intermediate",
+    Advanced = "advanced"
+}
+interface TestQuestions {
+    questionId: typeof TestQuestion;
+    order: number;
+}
+interface TestCategoryWithExpertise {
+    categoryId: typeof TestCategory;
+    expertiseLevel: ExpertiseLevel;
+}
+declare class Test extends EnduranceSchema {
+    title: string;
+    description: string;
+    companyId: typeof Company;
+    userId: typeof User;
+    questions: TestQuestions[];
+    state: TestState;
+    duration?: number;
+    passingScore?: number;
+    categories?: TestCategoryWithExpertise[];
+    targetJob: JobType;
+    seniorityLevel: SeniorityLevel;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+}
+declare const TestModel: import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+export default TestModel;

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

@@ -0,0 +1,123 @@
+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 Company from './company.model.js';
+import User from './user.model.js';
+var TestState;
+(function (TestState) {
+    // eslint-disable-next-line no-unused-vars
+    TestState["Draft"] = "draft";
+    // eslint-disable-next-line no-unused-vars
+    TestState["Published"] = "published";
+    // eslint-disable-next-line no-unused-vars
+    TestState["Archived"] = "archived";
+})(TestState || (TestState = {}));
+var JobType;
+(function (JobType) {
+    // eslint-disable-next-line no-unused-vars
+    JobType["FrontEnd"] = "front-end";
+    // eslint-disable-next-line no-unused-vars
+    JobType["BackEnd"] = "back-end";
+    // eslint-disable-next-line no-unused-vars
+    JobType["Fullstack"] = "fullstack";
+    // eslint-disable-next-line no-unused-vars
+    JobType["DevOps"] = "devops";
+    // eslint-disable-next-line no-unused-vars
+    JobType["Data"] = "data";
+})(JobType || (JobType = {}));
+var SeniorityLevel;
+(function (SeniorityLevel) {
+    // eslint-disable-next-line no-unused-vars
+    SeniorityLevel["Student"] = "student";
+    // eslint-disable-next-line no-unused-vars
+    SeniorityLevel["Junior"] = "junior";
+    // eslint-disable-next-line no-unused-vars
+    SeniorityLevel["Intermediate"] = "intermediate";
+    // eslint-disable-next-line no-unused-vars
+    SeniorityLevel["Senior"] = "senior";
+})(SeniorityLevel || (SeniorityLevel = {}));
+var ExpertiseLevel;
+(function (ExpertiseLevel) {
+    // eslint-disable-next-line no-unused-vars
+    ExpertiseLevel["Beginner"] = "beginner";
+    // eslint-disable-next-line no-unused-vars
+    ExpertiseLevel["Intermediate"] = "intermediate";
+    // eslint-disable-next-line no-unused-vars
+    ExpertiseLevel["Advanced"] = "advanced";
+})(ExpertiseLevel || (ExpertiseLevel = {}));
+let Test = class Test extends EnduranceSchema {
+    title;
+    description;
+    companyId;
+    userId;
+    questions;
+    state;
+    duration;
+    passingScore;
+    categories;
+    targetJob;
+    seniorityLevel;
+    static getModel() {
+        return TestModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Test.prototype, "title", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: false }),
+    __metadata("design:type", String)
+], Test.prototype, "description", void 0);
+__decorate([
+    EnduranceModelType.prop({ ref: () => Company, required: false }),
+    __metadata("design:type", Object)
+], Test.prototype, "companyId", void 0);
+__decorate([
+    EnduranceModelType.prop({ ref: () => User, required: false }),
+    __metadata("design:type", Object)
+], Test.prototype, "userId", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Object], required: true }),
+    __metadata("design:type", Array)
+], Test.prototype, "questions", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: TestState, default: TestState.Draft }),
+    __metadata("design:type", String)
+], Test.prototype, "state", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", Number)
+], Test.prototype, "duration", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", Number)
+], Test.prototype, "passingScore", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Object], required: false }),
+    __metadata("design:type", Array)
+], Test.prototype, "categories", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: JobType }),
+    __metadata("design:type", String)
+], Test.prototype, "targetJob", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: SeniorityLevel }),
+    __metadata("design:type", String)
+], Test.prototype, "seniorityLevel", void 0);
+Test = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], Test);
+const TestModel = EnduranceModelType.getModelForClass(Test);
+export default TestModel;

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

@@ -0,0 +1,18 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+import Company from './company.model.js';
+declare enum UserRole {
+    Admin = "admin",
+    Recruiter = "recruiter",
+    Candidate = "candidate"
+}
+declare class User extends EnduranceSchema {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    role: UserRole;
+    companyId?: typeof Company;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof User, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+}
+declare const UserModel: import("@typegoose/typegoose").ReturnModelType<typeof User, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+export default UserModel;

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

@@ -0,0 +1,64 @@
+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 Company from './company.model.js';
+var UserRole;
+(function (UserRole) {
+    // eslint-disable-next-line no-unused-vars
+    UserRole["Admin"] = "admin";
+    // eslint-disable-next-line no-unused-vars
+    UserRole["Recruiter"] = "recruiter";
+    // eslint-disable-next-line no-unused-vars
+    UserRole["Candidate"] = "candidate";
+})(UserRole || (UserRole = {}));
+let User = class User extends EnduranceSchema {
+    firstName;
+    lastName;
+    email;
+    password;
+    role;
+    companyId;
+    static getModel() {
+        return UserModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], User.prototype, "firstName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], User.prototype, "lastName", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, unique: true }),
+    __metadata("design:type", String)
+], User.prototype, "email", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], User.prototype, "password", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true, enum: UserRole }),
+    __metadata("design:type", String)
+], User.prototype, "role", void 0);
+__decorate([
+    EnduranceModelType.prop({ ref: () => Company }),
+    __metadata("design:type", Object)
+], User.prototype, "companyId", void 0);
+User = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], User);
+const UserModel = EnduranceModelType.getModelForClass(User);
+export default UserModel;

package/dist/modules/edrm-exams/routes/company.router.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceRouter } from '@programisto/endurance-core';
+declare class CompanyRouter extends EnduranceRouter {
+    constructor();
+    setupRoutes(): void;
+}
+declare const router: CompanyRouter;
+export default router;

package/dist/modules/edrm-exams/routes/company.router.js

@@ -0,0 +1,108 @@
+import { EnduranceRouter, EnduranceAuthMiddleware } from '@programisto/endurance-core';
+import Company from '../models/company.model.js';
+import User from '../models/user.model.js';
+class CompanyRouter extends EnduranceRouter {
+    constructor() {
+        super(EnduranceAuthMiddleware.getInstance());
+    }
+    setupRoutes() {
+        const authenticatedOptions = {
+            requireAuth: false,
+            permissions: []
+        };
+        // Obtenir une entreprise par son ID
+        this.get('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const company = await Company.findById(id);
+                if (!company) {
+                    return res.status(404).json({ message: 'Aucune entreprise trouvée avec cet ID' });
+                }
+                res.status(200).json({ data: company });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération de l\'entreprise : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Créer une nouvelle entreprise
+        this.post('/create', authenticatedOptions, async (req, res) => {
+            const { name, logo } = req.body;
+            if (!name || !logo) {
+                return res.status(400).json({ message: 'Erreur, le nom et le logo sont requis' });
+            }
+            try {
+                const newCompany = new Company({ name, logo });
+                await newCompany.save();
+                res.status(201).json({ message: 'Entreprise créée avec succès', company: newCompany });
+            }
+            catch (err) {
+                console.error('Erreur lors de la création de l\'entreprise : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Mettre à jour une entreprise
+        this.put('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            const { name, logo } = req.body;
+            try {
+                const company = await Company.findById(id);
+                if (!company) {
+                    return res.status(404).json({ message: 'Aucune entreprise trouvée avec cet ID' });
+                }
+                const updateData = {
+                    name: name || company.name,
+                    logo: logo || company.logo
+                };
+                await Company.findByIdAndUpdate(id, updateData, { new: true });
+                const updatedCompany = await Company.findById(id);
+                res.status(200).json({ message: 'Entreprise mise à jour', company: updatedCompany });
+            }
+            catch (err) {
+                console.error('Erreur lors de la mise à jour de l\'entreprise : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Supprimer une entreprise
+        this.delete('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const company = await Company.findByIdAndDelete(id);
+                if (!company) {
+                    return res.status(404).json({ message: 'Aucune entreprise trouvée avec cet ID' });
+                }
+                res.status(200).json({ message: 'Entreprise supprimée', company });
+            }
+            catch (err) {
+                console.error('Erreur lors de la suppression de l\'entreprise : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Obtenir le nombre d'utilisateurs d'une entreprise
+        this.get('/numberOfUser/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const users = await User.find({ companyId: id });
+                const numberOfUser = users.length;
+                res.status(200).json({ data: numberOfUser });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération du nombre d\'utilisateurs : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Lister toutes les entreprises
+        this.get('/', authenticatedOptions, async (req, res) => {
+            try {
+                const companies = await Company.find();
+                res.status(200).json({ array: companies });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération des entreprises : ', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+    }
+}
+const router = new CompanyRouter();
+export default router;

package/dist/modules/edrm-exams/routes/exams-candidate.router.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceRouter } from '@programisto/endurance-core';
+declare class CandidateRouter extends EnduranceRouter {
+    constructor();
+    setupRoutes(): void;
+}
+declare const router: CandidateRouter;
+export default router;