/*

* =================================================================
* /models/[Link]
* =================================================================
* The core of your data partitioning strategy. Almost every
* other model will be associated with an AcademicYear.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class AcademicYear extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
// This ID will be a foreign key in most other tables
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: { // e.g., "2024-2025"
type: [Link],
allowNull: false,
},
startDate: {
type: [Link],
allowNull: false,
},
endDate: {
type: [Link],
allowNull: false,
},
isActive: { // To mark the currently active year
type: [Link],
defaultValue: false,
},
schoolId: {
type: [Link],
allowNull: false,
references: {
model: 'Schools',
key: 'id',
},
},
}, {
sequelize,
modelName: 'AcademicYear',
 });
return AcademicYear;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* For school-wide or targeted announcements.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Announcement extends Model {
static associate(models) {
[Link]([Link], { as: 'author', foreignKey:
'authorId' });
[Link]([Link], { foreignKey:
'academicYearId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
title: {
type: [Link],
allowNull: false,
},
content: {
type: [Link],
allowNull: false,
},
authorId: { type: [Link], allowNull: false },
academicYearId: { type: [Link], allowNull: false },
publishDate: [Link],
// Target specific roles or classes using JSON
// e.g., { "roles": [2, 4], "classes": ["uuid-of-class-1"] }
target: [Link],
}, {
sequelize,
modelName: 'Announcement',
});
return Announcement;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* A polymorphic table to handle all file uploads.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Attachment extends Model {
static associate(models) {
// Polymorphic associations are set up in the related models
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
fileName: {
type: [Link],
allowNull: false,
},
fileUrl: {
type: [Link],
allowNull: false,
},
fileType: [Link], // MIME type
fileSize: [Link], // in bytes
relatedId: { // The ID of the model it's related to (e.g., reportCardId)
type: [Link],
allowNull: false,
},
relatedType: { // The name of the model it's related to (e.g.,
'reportCard')
type: [Link],
allowNull: false,
},
}, {
sequelize,
modelName: 'Attachment',
indexes: [
{ fields: ['relatedId', 'relatedType'] }
 ]
});
return Attachment;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Tracks student attendance.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Attendance extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'classId' });
[Link]([Link], { foreignKey: 'subjectId' }); //
Optional: for subject-level attendance
[Link]([Link], { foreignKey: 'academicYearId'
});
[Link]([Link], { as: 'takenBy', foreignKey:
'teacherId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
studentId: { type: [Link], allowNull: false },
classId: { type: [Link], allowNull: false },
subjectId: { type: [Link], allowNull: true },
academicYearId: { type: [Link], allowNull: false },
teacherId: { type: [Link], allowNull: false },
date: {
type: [Link],
allowNull: false,
},
status: {
type: [Link]('present', 'absent', 'late', 'excused'),
allowNull: false,
},
remarks: [Link],
 }, {
sequelize,
modelName: 'Attendance',
indexes: [{
unique: true,
fields: ['studentId', 'date', 'subjectId'] // Prevent duplicate entries
for the same student, day, and subject
}]
});
return Attendance;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* For tracking important changes to data for security and accountability.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class AuditLog extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'userId' });
}
}
[Link]({
id: {
type: [Link],
autoIncrement: true,
primaryKey: true,
},
userId: {
type: [Link],
allowNull: true, // System actions might not have a user
},
action: { // e.g., 'CREATE_GRADE', 'UPDATE_INVOICE_STATUS',
'DELETE_STUDENT'
type: [Link],
allowNull: false,
},
tableName: [Link],
recordId: [Link],
details: [Link], // e.g., 'Changed status from unpaid to paid'
ipAddress: [Link],
 }, {
sequelize,
modelName: 'AuditLog',
});
return AuditLog;
};

/*
* =================================================================
* /models/[Link] (Previously [Link])
* =================================================================
* Represents a generated report card document for a student.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Bulletin extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
[Link]([Link], { foreignKey: 'academicYearId'
});
[Link]([Link], { foreignKey: 'periodId' });
[Link]([Link], { foreignKey: 'classId' });
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], {
foreignKey: 'relatedId',
constraints: false,
scope: {
relatedType: 'bulletin'
}
});
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
schoolId: { type: [Link], allowNull: false },
academicYearId: { type: [Link], allowNull: false },
periodId: { type: [Link], allowNull: false },
classId: { type: [Link], allowNull: false },
studentId: { type: [Link], allowNull: false },
generatedAt: {
type: [Link],
 defaultValue: [Link],
},
overallScore: [Link],
overallRank: [Link],
homeroomTeacherComment: [Link], // Commentaire du titulaire
deanOfStudiesComment: [Link], // Commentaire du préfet des études
principalComment: [Link], // Commentaire du directeur
}, {
sequelize,
modelName: 'Bulletin',
indexes: [{
unique: true,
fields: ['studentId', 'periodId'] // An student can only have one
bulletin per period
}]
});
return Bulletin;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* A specific class for a given year, e.g., 'Grade 7A - 2024/2025'
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Class extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'levelId' });
[Link]([Link], { foreignKey: 'academicYearId' });
[Link]([Link], { as: 'homeroomTeacher', foreignKey:
'homeroomTeacherId' });
[Link]([Link], { foreignKey: 'classId' });
[Link]([Link], { foreignKey: 'classId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: { // e.g., 'A', 'B', 'Science Stream'
type: [Link],
 allowNull: false,
},
levelId: {
type: [Link],
allowNull: false,
references: {
model: 'Levels',
key: 'id',
},
},
academicYearId: {
type: [Link],
allowNull: false,
references: {
model: 'AcademicYears',
key: 'id',
},
},
homeroomTeacherId: {
type: [Link],
allowNull: true, // A class might not have a homeroom teacher assigned
yet
references: {
model: 'Teachers',
key: 'id',
},
},
}, {
sequelize,
modelName: 'Class',
// Ensure a class name is unique within a level for a given year
indexes: [{
unique: true,
fields: ['name', 'levelId', 'academicYearId']
}]
});
return Class;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Logs student disciplinary issues.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class DisciplinaryIncident extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId'
});
[Link]([Link], { as: 'reportedBy',
foreignKey: 'reportedById' });
[Link]([Link], { foreignKey:
'academicYearId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
studentId: { type: [Link], allowNull: false },
reportedById: { type: [Link], allowNull: false },
academicYearId: { type: [Link], allowNull: false },
incidentDate: {
type: [Link],
defaultValue: [Link]
},
title: {
type: [Link],
allowNull: false
},
description: {
type: [Link],
allowNull: false
},
actionTaken: [Link],
}, {
sequelize,
modelName: 'DisciplinaryIncident',
});
return DisciplinaryIncident;
};

/*
=================================================================
/models/[Link] (NEW FILE)
Purpose: Tracks a student's discipline points for a specific period.
=================================================================
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class DisciplinePoint extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'periodId' });
[Link]([Link], { foreignKey:
'academicYearId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
studentId: {
type: [Link],
allowNull: false,
},
periodId: {
type: [Link],
allowNull: false,
},
academicYearId: {
type: [Link],
allowNull: false,
},
points: {
type: [Link],
allowNull: false,
defaultValue: 60,
}
}, {
sequelize,
modelName: 'DisciplinePoint',
// Ensure a student has only one discipline point record per period
indexes: [
{
unique: true,
fields: ['studentId', 'periodId', 'academicYearId']
}
]
});
return DisciplinePoint;
};
/*
* =================================================================
* /models/[Link]
* =================================================================
* This critical table registers a student in a class for an academic year.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Enrollment extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'classId' });
[Link]([Link], { foreignKey: 'academicYearId'
});
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
studentId: {
type: [Link],
allowNull: false,
references: {
model: 'Students',
key: 'id',
},
},
classId: {
type: [Link],
allowNull: false,
references: {
model: 'Classes',
key: 'id',
},
},
academicYearId: {
type: [Link],
allowNull: false,
references: {
model: 'AcademicYears',
key: 'id',
},
},
 enrollmentDate: {
type: [Link],
defaultValue: [Link],
},
status: {
type: [Link]('enrolled', 'withdrawn', 'graduated'),
defaultValue: 'enrolled',
},
}, {
sequelize,
modelName: 'Enrollment',
// A student can only be enrolled in one class per academic year
indexes: [{
unique: true,
fields: ['studentId', 'academicYearId']
}]
});
return Enrollment;
};

/*
=================================================================
/models/[Link] (UPDATED)
Purpose: Weight is now an integer, and isExam and classId fields are added.
=================================================================
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class EvaluationType extends Model {
static associate(models) {
[Link]([Link], { foreignKey:
'academicYearId' });
[Link]([Link], { foreignKey: 'evaluationTypeId'
});
[Link]([Link], { foreignKey: 'classId' }); // <-
- NEW ASSOCIATION
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
 type: [Link],
allowNull: false,
},
weight: {
type: [Link], // <-- UPDATED DATA TYPE
allowNull: false,
defaultValue: 0
},
isExam: { // <-- NEW FIELD
type: [Link],
allowNull: false,
defaultValue: false,
},
academicYearId: {
type: [Link],
allowNull: false,
references: {
model: 'AcademicYears',
key: 'id',
},
},
classId: { // <-- NEW FIELD
type: [Link],
allowNull: true,
Class: {
model: 'AcademicYears',
key: 'id',
},
}
}, {
sequelize,
modelName: 'EvaluationType',
});
return EvaluationType;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Defines types of fees, e.g., 'Tuition', 'Uniform', 'Transportation'.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
 class FeeType extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'academicYearId'
});
[Link]([Link], { foreignKey: 'feeTypeId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
description: [Link],
academicYearId: {
type: [Link],
allowNull: false,
references: {
model: 'AcademicYears',
key: 'id',
},
},
}, {
sequelize,
modelName: 'FeeType',
});
return FeeType;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Records a student's grade for a specific evaluation.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Grade extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'subjectId' });
 [Link]([Link], { foreignKey: 'periodId' });
[Link]([Link], { foreignKey: 'evaluationTypeId'
});
[Link]([Link], { as: 'gradingTeacher', foreignKey:
'teacherId' });
[Link]([Link], { foreignKey: 'academicYearId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
score: {
type: [Link],
allowNull: false,
},
comments: [Link],
studentId: { type: [Link], allowNull: false },
subjectId: { type: [Link], allowNull: false },
periodId: { type: [Link], allowNull: false },
evaluationTypeId: { type: [Link], allowNull: false },
teacherId: { type: [Link], allowNull: false }, // Who entered the
grade
academicYearId: { type: [Link], allowNull: false },
}, {
sequelize,
modelName: 'Grade',
});
return Grade;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Represents a bill issued to a student.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Invoice extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'feeTypeId' });
 [Link]([Link], { foreignKey: 'academicYearId'
});
[Link]([Link], { foreignKey: 'invoiceId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
studentId: { type: [Link], allowNull: false },
academicYearId: { type: [Link], allowNull: false },
issueDate: {
type: [Link],
defaultValue: [Link],
},
dueDate: [Link],
totalAmount: {
type: [Link](10, 2),
allowNull: false,
},
amountPaid: {
type: [Link](10, 2),
defaultValue: 0.00,
},
feeTypeId: {
type: [Link],
allowNull: true,
},
description: {
type: [Link],
allowNull: true,
},
status: {
type: [Link]('draft', 'unpaid', 'paid', 'partially_paid',
'overdue', 'void'),
defaultValue: 'unpaid',
},
}, {
sequelize,
modelName: 'Invoice',
});
return Invoice;
};
/*
* =================================================================
* /models/[Link]
* =================================================================
* e.g., 'Grade 1', 'Grade 2', ... 'Grade 12'
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Level extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'sectionId' });
[Link]([Link], { foreignKey: 'levelId' });
}
}
[Link]({
id: {
type: [Link],
autoIncrement: true,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
sectionId: {
type: [Link],
allowNull: false,
references: {
model: 'Sections',
key: 'id',
},
},
}, {
sequelize,
modelName: 'Level',
});
return Level;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Parent-specific information.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Parent extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'profileId' });
[Link]([Link], { through: 'ParentStudents',
foreignKey: 'parentId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
profileId: {
type: [Link],
allowNull: false,
references: {
model: 'Profiles',
key: 'id',
},
},
occupation: [Link],
}, {
sequelize,
modelName: 'Parent',
});
return Parent;
};

/*
* =================================================================
* /models/[Link] (Junction Table)
* =================================================================
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class ParentStudents extends Model {}
[Link]({
parentId: {
type: [Link],
primaryKey: true,
},
 studentId: {
type: [Link],
primaryKey: true,
},
relationshipType: { // e.g., 'Father', 'Mother', 'Guardian'
type: [Link],
}
}, {
sequelize,
modelName: 'ParentStudents',
timestamps: false
});
return ParentStudents;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Records a payment made against an invoice.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Payment extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'invoiceId' });
[Link]([Link], { as: 'processedBy', foreignKey:
'processedById' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
invoiceId: { type: [Link], allowNull: false },
amount: {
type: [Link](10, 2),
allowNull: false,
},
paymentDate: {
type: [Link],
defaultValue: [Link],
},
 paymentMethod: [Link]('Cash', 'Bank Transfer', 'Mobile Money',
'Card'),
transactionId: [Link], // For external payment references
processedById: { type: [Link], allowNull: false }, // User who
recorded the payment
}, {
sequelize,
modelName: 'Payment',
});
return Payment;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Defines grading periods for a year, e.g., 'Term 1', 'Semester 2'.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Period extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'academicYearId' });
[Link]([Link], { foreignKey: 'periodId' });
[Link]([Link], { foreignKey: 'periodId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
startDate: [Link],
endDate: [Link],
academicYearId: {
type: [Link],
allowNull: false,
references: {
model: 'AcademicYears',
 key: 'id',
},
},
}, {
sequelize,
modelName: 'Period',
});
return Period;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Stores personal information for all users.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Profile extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'userId' });
[Link]([Link], { foreignKey: 'profileId' });
[Link]([Link], { foreignKey: 'profileId' });
[Link]([Link], { foreignKey: 'profileId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
userId: {
type: [Link],
allowNull: false,
references: {
model: 'Users',
key: 'id',
},
},
firstName: {
type: [Link],
allowNull: false,
},
lastName: {
 type: [Link],
allowNull: false,
},
dateOfBirth: [Link],
gender: [Link]('Male', 'Female', 'Other'),
address: [Link],
phoneNumber: [Link],
profilePictureUrl: [Link],
}, {
sequelize,
modelName: 'Profile',
});
return Profile;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Defines user roles for access control.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Role extends Model {
static associate(models) {
[Link]([Link], { through: 'UserRoles', foreignKey:
'roleId' });
}
}
[Link]({
id: {
type: [Link],
autoIncrement: true,
primaryKey: true,
},
name: { // e.g., 'Directeur', 'Préfet des Études', 'Préfet de Discipline',
'Économe', 'Encadreur', 'Professeur', 'Parent', 'Étudiant'
type: [Link],
allowNull: false,
unique: true,
},
}, {
sequelize,
modelName: 'Role',
timestamps: false,
 });
return Role;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* The top-level entity. Your entire application will operate
* within the context of a single school.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class School extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
[Link]([Link], { foreignKey: 'schoolId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
address: [Link],
phone: [Link],
email: {
type: [Link],
validate: { isEmail: true },
},
logoUrl: [Link],
}, {
sequelize,
modelName: 'School',
});
return School;
};
/*
* =================================================================
* /models/[Link]
* =================================================================
* e.g., 'Primary School', 'Middle School', 'High School'
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Section extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
[Link]([Link], { foreignKey: 'sectionId' });
}
}
[Link]({
id: {
type: [Link],
autoIncrement: true,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
schoolId: {
type: [Link],
allowNull: false,
references: {
model: 'Schools',
key: 'id',
},
},
}, {
sequelize,
modelName: 'Section',
});
return Section;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Student-specific information.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Student extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'profileId' });
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { through: 'ParentStudents',
foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'studentId'
});
[Link]([Link], { foreignKey: 'studentId' });
[Link]([Link], { foreignKey: 'studentId' }); //
<-- NEW ASSOCIATION
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
profileId: {
type: [Link],
allowNull: false,
references: {
model: 'Profiles',
key: 'id',
},
},
studentIdNumber: { // School-specific ID
type: [Link],
allowNull: false,
unique: true,
},
admissionDate: [Link],
}, {
sequelize,
modelName: 'Student',
});
return Student;
};
/*
* =================================================================
* /models/[Link]
* =================================================================
* e.g., 'Mathematics', 'History', 'Physics'
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Subject extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
[Link]([Link], { foreignKey: 'subjectId' });
[Link]([Link], { foreignKey: 'subjectId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: [Link],
allowNull: false,
},
code: { // e.g., 'MATH101'
type: [Link],
unique: true,
},
schoolId: {
type: [Link],
allowNull: false,
references: {
model: 'Schools',
key: 'id',
},
}
}, {
sequelize,
modelName: 'Subject',
});
return Subject;
};

/*
 * =================================================================
* /models/[Link]
* =================================================================
* Teacher-specific information.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class Teacher extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'profileId' });
[Link]([Link], { foreignKey: 'teacherId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
profileId: {
type: [Link],
allowNull: false,
references: {
model: 'Profiles',
key: 'id',
},
},
employeeIdNumber: {
type: [Link],
allowNull: false,
unique: true,
},
qualifications: [Link],
hireDate: [Link],
}, {
sequelize,
modelName: 'Teacher',
});
return Teacher;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
 * Assigns a teacher to teach a subject in a specific class for a year.
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class TeacherAssignment extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'teacherId'
});
[Link]([Link], { foreignKey: 'subjectId'
});
[Link]([Link], { foreignKey: 'classId' });
[Link]([Link], { foreignKey:
'academicYearId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
teacherId: {
type: [Link],
allowNull: false,
references: {
model: 'Teachers',
key: 'id',
},
},
subjectId: {
type: [Link],
allowNull: false,
references: {
model: 'Subjects',
key: 'id',
},
},
classId: {
type: [Link],
allowNull: false,
references: {
model: 'Classes',
key: 'id',
},
},
academicYearId: {
type: [Link],
allowNull: false,
 references: {
model: 'AcademicYears',
key: 'id',
},
},
}, {
sequelize,
modelName: 'TeacherAssignment',
indexes: [{ // A teacher can only be assigned to a specific class/subject
combo once per year
unique: true,
fields: ['teacherId', 'subjectId', 'classId', 'academicYearId']
}]
});
return TeacherAssignment;
};

/*
* =================================================================
* /models/[Link]
* =================================================================
* Handles authentication. Kept lean on purpose.
* Personal data is in the Profile model.
*/
'use strict';
const { Model } = require('sequelize');
const bcrypt = require('bcryptjs');

[Link] = (sequelize, DataTypes) => {

class User extends Model {
static associate(models) {
[Link]([Link], { foreignKey: 'schoolId' });
[Link]([Link], { foreignKey: 'userId' });
[Link]([Link], { through: 'UserRoles', foreignKey:
'userId' });
}
}
[Link]({
id: {
type: [Link],
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
email: {
type: [Link],
allowNull: false,
 unique: true,
validate: { isEmail: true },
},
password: {
type: [Link],
allowNull: false,
},
status: {
type: [Link]('active', 'inactive', 'suspended'),
defaultValue: 'active',
},
lastLogin: [Link],
schoolId: {
type: [Link],
allowNull: false,
references: {
model: 'Schools',
key: 'id',
},
},
}, {
sequelize,
modelName: 'User',
hooks: {
beforeCreate: async (user) => {
if ([Link]) {
const salt = await [Link](10);
[Link] = await [Link]([Link], salt);
}
},
beforeUpdate: async (user) => {
if ([Link]('password')) {
const salt = await [Link](10);
[Link] = await [Link]([Link], salt);
}
},
}
});

// Instance method to compare passwords

[Link] = async function(password) {
return await [Link](password, [Link]);
}

return User;
};
/*
* =================================================================
* /models/[Link] (Junction Table)
* =================================================================
*/
'use strict';
const { Model } = require('sequelize');
[Link] = (sequelize, DataTypes) => {
class UserRoles extends Model {}
[Link]({
userId: {
type: [Link],
primaryKey: true,
},
roleId: {
type: [Link],
primaryKey: true,
},
}, {
sequelize,
modelName: 'UserRoles',
timestamps: false
});
return UserRoles;
};
import { Sequelize } from 'sequelize';
import initSchoolModel from '@/models/[Link]';
import initAcademicYearModel from '@/models/[Link]';
import initUserModel from '@/models/[Link]';
import initRoleModel from '@/models/[Link]';
import initProfileModel from '@/models/[Link]';
import initSectionModel from '@/models/[Link]';
import initLevelModel from '@/models/[Link]';
import initClassModel from '@/models/[Link]';
import initSubjectModel from '@/models/[Link]';
import initStudentModel from '@/models/[Link]';
import initParentModel from '@/models/[Link]';
import initTeacherModel from '@/models/[Link]';
import initEnrollmentModel from '@/models/[Link]';
import initTeacherAssignmentModel from '@/models/[Link]';
import initPeriodModel from '@/models/[Link]';
import initEvaluationTypeModel from '@/models/[Link]';
import initGradeModel from '@/models/[Link]';
import initBulletinModel from '@/models/[Link]';
import initFeeTypeModel from '@/models/[Link]';
import initInvoiceModel from '@/models/[Link]';
import initPaymentModel from '@/models/[Link]';
import initAttendanceModel from '@/models/[Link]';
import initDisciplinaryIncidentModel from
'@/models/[Link]';
import initAnnouncementModel from '@/models/[Link]';
import initAttachmentModel from '@/models/[Link]';
import initAuditLogModel from '@/models/[Link]';
import initDisciplinePointModel from '@/models/[Link]';
// Importez les modèles de tables de jonction si vous les avez dans des
fichiers séparés
import initUserRolesModel from '@/models/[Link]';
import initParentStudentsModel from '@/models/[Link]';

const env = [Link].NODE_ENV || 'development';

const config = require(__dirname + '/../config/[Link]')[env];

let sequelize;
if (config.use_env_variable) {
sequelize = new Sequelize([Link][config.use_env_variable], config);
} else {
sequelize = new Sequelize([Link], [Link], [Link],
config);
}

const db = {};

// Initialisation statique de tous les modèles

[Link] = initSchoolModel(sequelize, [Link]);
[Link] = initAcademicYearModel(sequelize, [Link]);
[Link] = initUserModel(sequelize, [Link]);
[Link] = initRoleModel(sequelize, [Link]);
[Link] = initProfileModel(sequelize, [Link]);
[Link] = initSectionModel(sequelize, [Link]);
[Link] = initLevelModel(sequelize, [Link]);
[Link] = initClassModel(sequelize, [Link]);
[Link] = initSubjectModel(sequelize, [Link]);
[Link] = initStudentModel(sequelize, [Link]);
[Link] = initParentModel(sequelize, [Link]);
[Link] = initTeacherModel(sequelize, [Link]);
[Link] = initEnrollmentModel(sequelize, [Link]);
[Link] = initTeacherAssignmentModel(sequelize,
[Link]);
[Link] = initPeriodModel(sequelize, [Link]);
[Link] = initEvaluationTypeModel(sequelize, [Link]);
[Link] = initGradeModel(sequelize, [Link]);
[Link] = initBulletinModel(sequelize, [Link]);
[Link] = initFeeTypeModel(sequelize, [Link]);
[Link] = initInvoiceModel(sequelize, [Link]);
[Link] = initPaymentModel(sequelize, [Link]);
[Link] = initAttendanceModel(sequelize, [Link]);
[Link] = initDisciplinaryIncidentModel(sequelize,
[Link]);
[Link] = initAnnouncementModel(sequelize, [Link]);
[Link] = initAttachmentModel(sequelize, [Link]);
[Link] = initAuditLogModel(sequelize, [Link]);
[Link] = initUserRolesModel(sequelize, [Link]);
[Link] = initDisciplinePointModel(sequelize, [Link]);
[Link] = initParentStudentsModel(sequelize, [Link]);

// Établir les associations

[Link](db).forEach(modelName => {
if (db[modelName].associate) {
db[modelName].associate(db);
}
});

[Link] = sequelize;
[Link] = Sequelize;

export default db;