model users transformed to mysql

database/Models/Users.backup.js

@@ -0,0 +1,149 @@
+const { database } = require('../database')
+const bcrypt = require('bcryptjs')
+
+// Function to insert a user into the database
+async function insertUser(username, email, password, roles) {
+  const saltRounds = 10
+
+  try {
+    // Await the bcrypt hashing to complete before proceeding
+    const hashedPassword = await bcrypt.hash(password, saltRounds)
+
+    // Prepare and run the insert query using the hashed password
+    const insertUserQuery = database.prepare(
+      'INSERT INTO users (username, email, password, roles) VALUES (?, ?, ?, ?)'
+    )
+    const insertedUser = await insertUserQuery.run(username, email, hashedPassword, roles)
+
+    return insertedUser
+  } catch (err) {
+    return err
+  }
+}
+
+// Function to fetch all users from the database
+async function getAllUsers() {
+  const getUsersQuery = database.prepare('SELECT * FROM users')
+  let response = await getUsersQuery.all()
+
+  return response
+}
+
+// Function to login a user
+async function loginUser(username, password) {
+  // Prepare the query to get the user by username
+  const loginUserQuery = database.prepare('SELECT * FROM users WHERE LOWER(username) = ?')
+
+  try {
+    // Execute the query and get the user from the database
+    const user = await loginUserQuery.get(username.toLowerCase())
+
+    if (user) {
+      // Use bcrypt to compare the provided password with the stored hashed password
+      const isPasswordValid = await bcrypt.compare(password, user.password)
+
+      if (isPasswordValid) {
+        // If password matches, return the user
+        return user
+      } else {
+        // If password does not match
+        console.log('Invalid password')
+      }
+    } else {
+      // If no user is found with the provided username
+      console.log('User not found')
+    }
+  } catch (err) {
+    console.error('Error during login:', err)
+  }
+}
+
+/**
+ * function to use in forgit password
+ *
+ * @param {*} email
+ * @param {*} password
+ * @param {*} passwordConfirmation
+ * @returns
+ */
+async function forgotPassword(email, password, passwordConfirmation) {
+  const saltRounds = 10
+  const forgotPasswordQuery = database.prepare('SELECT * FROM users WHERE email = ?')
+
+  if (password == passwordConfirmation) {
+    const user = await forgotPasswordQuery.get(email)
+
+    if (user) {
+      const updateQuery = database.prepare('UPDATE users SET password = ? WHERE email = ?')
+      const hashedPassword = await bcrypt.hash(password, saltRounds)
+
+      try {
+        await updateQuery.run(hashedPassword, email)
+
+        return { message: 'Mot de passe modifier avec succes', status: 200 }
+      } catch (error) {
+        console.error('Error updating password:', error)
+      }
+    } else {
+      return { message: 'Email non trouver', status: 404 }
+    }
+  } else {
+    return { message: 'Mot de passe ne correspond pas', status: 401 }
+  }
+}
+
+/**
+ * function to use when updatign the users
+ *
+ * @param {*} username
+ * @param {*} email
+ * @param {*} password
+ * @param {*} id
+ * @returns promise
+ */
+async function updateUser(username, email, password, id) {
+  const saltRounds = 10
+
+  try {
+    let query
+    let response
+
+    if (password === '') {
+      // Update without changing the password
+      if (username === '' && email !== '') {
+        query = database.prepare('UPDATE users SET email = ? WHERE id = ?')
+        response = await query.run(email, id)
+      } else if (email === '' && username !== '') {
+        query = database.prepare('UPDATE users SET username = ? WHERE id = ?')
+        response = await query.run(username, id)
+      } else if (username !== '' && email !== '') {
+        query = database.prepare('UPDATE users SET username = ?, email = ? WHERE id = ?')
+        response = await query.run(username, email, id)
+      }
+    } else {
+      // Update with a new hashed password
+      const hashedPassword = await bcrypt.hash(password, saltRounds)
+      query = database.prepare(
+        'UPDATE users SET username = ?, email = ?, password = ? WHERE id = ?'
+      )
+      response = await query.run(username, email, hashedPassword, id)
+    }
+
+    // Fetch the updated user after the update
+    const getUserQuery = database.prepare('SELECT * FROM users WHERE id = ?')
+    const updatedUser = await getUserQuery.get(id)
+
+    return updatedUser // Return the updated user
+  } catch (error) {
+    console.error('Error updating user:', error)
+    throw error // Throw error to handle it in calling function if needed
+  }
+}
+
+module.exports = {
+  getAllUsers,
+  insertUser,
+  loginUser,
+  forgotPassword,
+  updateUser
+}

database/Models/Users.js

@@ -1,149 +1,177 @@
-const { database } = require('../database')
+const { pool } = require('../database')
 const bcrypt = require('bcryptjs')
 
-// Function to insert a user into the database
+/**
+ * function to insert new user
+ * @param {String} username
+ * @param {String} email
+ * @param {String} password
+ * @param {String} roles
+ * @returns {Object}
+ */
 async function insertUser(username, email, password, roles) {
-  const saltRounds = 10
+  const saltRound = 10
 
   try {
-    // Await the bcrypt hashing to complete before proceeding
+    const hashedPassword = await bcrypt.hash(password, saltRound)
-    const hashedPassword = await bcrypt.hash(password, saltRounds)
 
-    // Prepare and run the insert query using the hashed password
+    const sql = `
-    const insertUserQuery = database.prepare(
+      INSERT INTO users (username, email, password, roles) VALUES (?, ?, ?, ?)
-      'INSERT INTO users (username, email, password, roles) VALUES (?, ?, ?, ?)'
+    `
-    )
+    const [result] = await pool.query(sql, [username, email, hashedPassword, roles])
-    const insertedUser = await insertUserQuery.run(username, email, hashedPassword, roles)
 
-    return insertedUser
+    // result.insertId contains the new user ID
-  } catch (err) {
+    return {
-    return err
+      success: true,
+      id: result.insertId
+    }
+  } catch (error) {
+    return { success: false, error: error }
   }
 }
 
-// Function to fetch all users from the database
+/**
+ * function to get all users
+ * @returns {Array}
+ */
 async function getAllUsers() {
-  const getUsersQuery = database.prepare('SELECT * FROM users')
+  const sql = `SELECT * FROM users`
-  let response = await getUsersQuery.all()
+
+  try {
+    const [rows] = await pool.query(sql)
+
+    return rows
+  } catch (error) {
+    return 'failled to get users'
+  }
+}
+
+/**
+ * function to get one users
+ * @param {Number} id
+ * @returns {Object}
+ */
+async function getUserById(id) {
+  const sql = `SELECT * FROM users WHERE id = ?`
+  const [rows] = await pool.query(sql, [id])
 
-  return response
+  if (rows.length > 0) {
+    return rows[0]
+  } else {
+    return null
+  }
 }
 
-// Function to login a user
+/**
-async function loginUser(username, password) {
+ * function used when users try to log in
-  // Prepare the query to get the user by username
+ * @param {String} username
-  const loginUserQuery = database.prepare('SELECT * FROM users WHERE LOWER(username) = ?')
+ * @param {String} password
+ * @returns {Object}
+ */
+async function loginUsers(username, password) {
+  const sql = `SELECT * FROM users WHERE LOWER(username) = ?`
 
   try {
-    // Execute the query and get the user from the database
+    const [rows] = pool.query(sql, username)
-    const user = await loginUserQuery.get(username.toLowerCase())
-
-    if (user) {
-      // Use bcrypt to compare the provided password with the stored hashed password
-      const isPasswordValid = await bcrypt.compare(password, user.password)
 
-      if (isPasswordValid) {
+    if (rows.length === 0) {
-        // If password matches, return the user
+      return { success: false, error: 'Utilisateur inexistant' }
-        return user
-      } else {
-        // If password does not match
-        console.log('Invalid password')
     }
-    } else {
+
-      // If no user is found with the provided username
+    const user = rows[0]
-      console.log('User not found')
+
+    // compare the password
+    const passwordMatch = await bcrypt.compare(password, user.password)
+
+    if (!passwordMatch) {
+      return { success: false, error: 'Mot de passe incorrect' }
     }
-  } catch (err) {
+
-    console.error('Error during login:', err)
+    // delete the key password before return a user object
+    delete user.password
+
+    return { success: true, user }
+  } catch (error) {
+    return { error: 'erreur lors du login' }
   }
 }
 
 /**
- * function to use in forgit password
+ * function to update users
- *
+ * @param {String} username
- * @param {*} email
+ * @param {String} email
- * @param {*} password
+ * @param {String} password
- * @param {*} passwordConfirmation
+ * @param {String} roles
- * @returns
+ * @param {Number} id
+ * @returns {Object}
  */
-async function forgotPassword(email, password, passwordConfirmation) {
+async function updateUser(username, email, password, roles, id) {
-  const saltRounds = 10
+  let sql, params
-  const forgotPasswordQuery = database.prepare('SELECT * FROM users WHERE email = ?')
 
-  if (password == passwordConfirmation) {
+  if (password !== null) {
-    const user = await forgotPasswordQuery.get(email)
+    const hashedPassword = await bcrypt.hash(password, 10)
-
+    sql = `UPDATE users SET username = ?, email = ?, password = ?, roles = ? WHERE id = ?`
-    if (user) {
+    params = [username, email, hashedPassword, roles, id]
-      const updateQuery = database.prepare('UPDATE users SET password = ? WHERE email = ?')
+  } else {
-      const hashedPassword = await bcrypt.hash(password, saltRounds)
+    sql = `UPDATE users SET username = ?, email = ?, roles = ? WHERE id = ?`
+    params = [username, email, roles, id]
+  }
 
   try {
-        await updateQuery.run(hashedPassword, email)
+    const [result] = await pool.query(sql, params)
 
-        return { message: 'Mot de passe modifier avec succes', status: 200 }
+    if (result.affectedRows === 0) {
-      } catch (error) {
+      return {
-        console.error('Error updating password:', error)
+        success: false,
+        message: 'Utilisateur non trouvé ou aucune modification effectuée.'
       }
-    } else {
-      return { message: 'Email non trouver', status: 404 }
     }
-  } else {
+
-    return { message: 'Mot de passe ne correspond pas', status: 401 }
+    return {
+      success: true,
+      message: 'Utilisateur mis à jour avec succès.'
+    }
+  } catch (error) {
+    return { success: false, error: 'Erreur veullez réeseyer' }
   }
 }
 
 /**
- * function to use when updatign the users
+ * function to delete users
- *
+ * @param {Number} id
- * @param {*} username
+ * @returns {Object}
- * @param {*} email
- * @param {*} password
- * @param {*} id
- * @returns promise
  */
-async function updateUser(username, email, password, id) {
+async function deleteUser(id) {
-  const saltRounds = 10
+  const sql = `DELETE FROM users WHERE id = ?`
 
   try {
-    let query
+    const [result] = await pool.query(sql, [id])
-    let response
+
-
+    if (result.affectedRows === 0) {
-    if (password === '') {
+      return {
-      // Update without changing the password
+        success: false,
-      if (username === '' && email !== '') {
+        message: 'Utilisateur non trouvé.'
-        query = database.prepare('UPDATE users SET email = ? WHERE id = ?')
-        response = await query.run(email, id)
-      } else if (email === '' && username !== '') {
-        query = database.prepare('UPDATE users SET username = ? WHERE id = ?')
-        response = await query.run(username, id)
-      } else if (username !== '' && email !== '') {
-        query = database.prepare('UPDATE users SET username = ?, email = ? WHERE id = ?')
-        response = await query.run(username, email, id)
       }
-    } else {
-      // Update with a new hashed password
-      const hashedPassword = await bcrypt.hash(password, saltRounds)
-      query = database.prepare(
-        'UPDATE users SET username = ?, email = ?, password = ? WHERE id = ?'
-      )
-      response = await query.run(username, email, hashedPassword, id)
     }
 
-    // Fetch the updated user after the update
+    return {
-    const getUserQuery = database.prepare('SELECT * FROM users WHERE id = ?')
+      success: true,
-    const updatedUser = await getUserQuery.get(id)
+      message: 'Utilisateur supprimé avec succès.'
-
+    }
-    return updatedUser // Return the updated user
   } catch (error) {
-    console.error('Error updating user:', error)
+    console.error(error)
-    throw error // Throw error to handle it in calling function if needed
+    return {
+      success: false,
+      error: 'Erreur lors de la suppression, veuillez réessayer.'
+    }
   }
 }
 
 module.exports = {
-  getAllUsers,
   insertUser,
-  loginUser,
+  getAllUsers,
-  forgotPassword,
+  getUserById,
-  updateUser
+  loginUsers,
+  updateUser,
+  deleteUser
 }

database/database.backup.js

@@ -0,0 +1,444 @@
+const sqlite = require('better-sqlite3')
+const bcrypt = require('bcryptjs')
+
+
+// Construct the database path using the detected IP
+let dbPath = `./base/data.db`;
+
+// Connect to SQLite database with the initial path
+let database = new sqlite(dbPath);
+
+
+
+
+
+// Create the users table if it doesn't exist
+const createUserTableQuery = `
+  CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    username VARCHAR(200) NOT NULL,
+    email VARCHAR(250) NOT NULL UNIQUE,
+    password TEXT NOT NULL,
+    roles VARCHAR(250) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createUserTableQuery).run()
+
+// Insert a default admin user if not exists
+const insertDefaultUserQuery = `
+  INSERT INTO users (username, email, password, roles)
+  SELECT 'admin', 'admin@example.com', ?, 'admin'
+  WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = 'admin');
+`
+
+// Hash the password '1234' before storing
+const hashedPassword = bcrypt.hashSync('123456789', 10)
+database.prepare(insertDefaultUserQuery).run(hashedPassword)
+
+// create table for note status
+const createStatusTableQuery = `
+  CREATE TABLE IF NOT EXISTS status (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(200) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createStatusTableQuery).run()
+
+// create table for mention
+const createMentionTableQuery = `
+  CREATE TABLE IF NOT EXISTS mentions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(250) NOT NULL,
+    uniter VARCHAR(50) NOT NULL, -- Abréviation du nom
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createMentionTableQuery).run()
+
+// Create the niveau table if it doesn't exist
+const createNiveauTableQuery = `
+  CREATE TABLE IF NOT EXISTS niveaus (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(50) NOT NULL, -- Exemple: L1, L2, L3, etc.
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createNiveauTableQuery).run()
+
+// Create the etudiants table if it doesn't exist
+const createEtudiantsTableQuery = `
+  CREATE TABLE IF NOT EXISTS etudiants (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(250) DEFAULT NULL,
+    prenom VARCHAR(250) DEFAULT NULL,
+    photos TEXT DEFAULT NULL,
+    date_de_naissances DATE DEFAULT NULL,
+    niveau VARCHAR(250) NOT NULL, -- Clé étrangère vers niveaus
+    annee_scolaire VARCHAR(20) NOT NULL,
+    status INTEGER DEFAULT NULL,
+    mention_id INTEGER NOT NULL, -- Clé étrangère vers mentions
+    num_inscription TEXT NOT NULL,
+    sexe VARCHAR(20) DEFAULT NULL,
+    cin VARCHAR(250) DEFAULT NULL,
+    date_delivrance DEFAULT NULL,
+    nationalite DATE DEFAULT NULL,
+    annee_bacc DATE DEFAULT NULL,
+    serie VARCHAR(20) DEFAULT NULL,
+    boursier BOOLEAN DEFAULT FALSE,
+    domaine VARCHAR(250) DEFAULT NULL,
+    contact VARCHAR(20) DEFAULT NULL,
+    parcours VARCHAR(250) DEFAULT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (status) REFERENCES status(id),
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createEtudiantsTableQuery).run()
+
+// Create the notes table if it doesn't exist
+const createMatiereTableQuery = `
+  CREATE TABLE IF NOT EXISTS matieres (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(250) UNIQUE NOT NULL,
+    unite_enseignement VARCHAR(250) NOT NULL,
+    credit INTEGER NOT NULL,
+    heure INTEGER NOT NULL,
+    ue VARCHAR(10) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createMatiereTableQuery).run()
+
+// Create the semestre table if it doesn't exist
+const createSemestreTableQuery = `
+  CREATE TABLE IF NOT EXISTS semestres (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(30) NOT NULL, -- Exemple: S1, S2, S3, etc.
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createSemestreTableQuery).run()
+
+// Create the semestre table if it doesn't exist
+const createMatiere_mentionTableQuery = `
+  CREATE TABLE IF NOT EXISTS matiere_mention (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+    mention_id INTEGER NOT NULL, -- Clé étrangère vers mentions
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createMatiere_mentionTableQuery).run()
+
+const createMatiere_semestreTableQuery = `
+  CREATE TABLE IF NOT EXISTS matiere_semestre (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+    semestre_id INTEGER NOT NULL, -- Clé étrangère vers semestres
+    mention_id INTEGER NOT NULL, -- Clé étrangère vers niveaus
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+    FOREIGN KEY (semestre_id) REFERENCES semestres(id),
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createMatiere_semestreTableQuery).run()
+
+// Create the notes table if it doesn't exist
+const createNoteTableQuery = `
+  CREATE TABLE IF NOT EXISTS notes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+    etudiant_niveau VARCHAR(50) NOT NULL,
+    mention_id INTEGER NOT NULL,
+    note FLOAT DEFAULT NULL,
+    annee_scolaire VARCHAR(50) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createNoteTableQuery).run()
+
+// Create the notes second session table if it doesn't exist
+const createNoteRepechTableQuery = `
+  CREATE TABLE IF NOT EXISTS notesrepech (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+    etudiant_niveau VARCHAR(50) NOT NULL,
+    mention_id INTEGER NOT NULL,
+    note FLOAT DEFAULT NULL,
+    annee_scolaire VARCHAR(50) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createNoteRepechTableQuery).run()
+
+// create table for note système
+const createNoteSystemeTableQuery = `
+  CREATE TABLE IF NOT EXISTS notesystems (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    admis FLOAT NOT NULL DEFAULT 10,
+    redouble FLOAT NOT NULL DEFAULT 9.99,
+    renvoyer FLOAT NOT NULL DEFAULT 7.99,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createNoteSystemeTableQuery).run()
+
+// create table année scolaire
+const createAnneeScolaireTableQuery = `
+  CREATE TABLE IF NOT EXISTS anneescolaire (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    code VARCHAR(30) NOT NULL,
+    debut DATE NOT NULL,
+    fin DATE NOT NULL,
+    is_current INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createAnneeScolaireTableQuery).run()
+
+// create traitement systeme
+const createTraitementSystemQuery = `
+  CREATE TABLE IF NOT EXISTS traitmentsystem (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    code VARCHAR(30) NOT NULL,
+    debut DATE NOT NULL,
+    fin DATE NOT NULL,
+    is_finished INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createTraitementSystemQuery).run()
+
+const createNecessaryParameterTableQuery = `
+  CREATE TABLE IF NOT EXISTS nessesaryTable (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    uniter_heure  INTEGER NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createNecessaryParameterTableQuery).run()
+
+const createMatiereEnseignantTableQuery = `
+  CREATE TABLE IF NOT EXISTS matiereEnseignants (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    matiere_id INTEGER NOT NULL,
+    nom_enseignant VARCHAR(250) NOT NULL,
+    prenom_enseignant VARCHAR(250) NOT NULL,
+    contact VARCHAR(11) NOT NULL,
+    date DATE NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+  );
+`
+database.prepare(createMatiereEnseignantTableQuery).run()
+
+const createParcourTableQuery = `
+  CREATE TABLE IF NOT EXISTS parcours (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    nom VARCHAR(250) NOT NULL,
+    uniter VARCHAR(250) NOT NULL,
+    mention_id INTEGER DEFAULT NULL, -- Clé étrangère vers mentions
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createParcourTableQuery).run()
+
+const createParcourSemestreTableQuery = `
+  CREATE TABLE IF NOT EXISTS parcoursmatiere (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    matiere_id INTEGER NOT NULL,
+    parcour_id INTEGER NOT NULL,
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+    FOREIGN KEY (parcour_id) REFERENCES parcours(id)
+  );
+`
+database.prepare(createParcourSemestreTableQuery).run()
+
+const createTableEcolageQuery = `
+  CREATE TABLE IF NOT EXISTS trancheecolage (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    etudiant_id INTEGER NOT NULL,
+    tranchename VARCHAR(255) NOT NULL,
+    montant DOUBLE NOT NULL
+  );
+`
+database.prepare(createTableEcolageQuery).run()
+
+const createTableStoreIP = `
+  CREATE TABLE IF NOT EXISTS ipconfig (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    ipname VARCHAR(255) NOT NULL
+  );
+`;
+database.prepare(createTableStoreIP).run()
+
+// -------------------------------------- function pre-excuter --------------------------------------------
+
+async function insertStatusesIfNotExist() {
+  // Préparation des requêtes
+  const checkStatusQuery = database.prepare(`
+    SELECT COUNT(*) AS count FROM status WHERE nom = ?;
+  `)
+  const insertStatusQuery = database.prepare(`
+    INSERT INTO status (nom) VALUES (?);
+  `)
+
+  // Tableau des statuts à vérifier/insérer
+  const arrayStatus = ['Nouveau', 'Passant', 'Redoublant', 'Renvoyé', 'Ancien']
+
+  for (let index = 0; index < arrayStatus.length; index++) {
+    const statusName = arrayStatus[index]
+
+    // Vérification si le statut existe déjà
+    const result = checkStatusQuery.get(statusName)
+
+    // Si le statut n'existe pas, on l'insère
+    if (result.count === 0) {
+      insertStatusQuery.run(statusName)
+    }
+  }
+}
+// execute the function
+insertStatusesIfNotExist()
+
+async function insertDefaultNoteSystemIfNotExist() {
+  // Préparation de la requête pour vérifier si une entrée existe déjà
+  const checkNoteSystemQuery = database.prepare(`
+    SELECT COUNT(*) AS count FROM notesystems;
+  `)
+
+  // Préparation de la requête pour insérer une entrée par défaut
+  const insertNoteSystemQuery = database.prepare(`
+    INSERT INTO notesystems (admis, redouble, renvoyer)
+    VALUES (?, ?, ?);
+  `)
+
+  // Valeurs par défaut à insérer
+  const defaultValues = {
+    admis: 10.0,
+    redouble: 9.99,
+    renvoyer: 7.99
+  }
+
+  // Vérification si une entrée existe déjà
+  const result = checkNoteSystemQuery.get()
+
+  if (result.count === 0) {
+    // Insérer les valeurs par défaut si aucune entrée n'existe
+    insertNoteSystemQuery.run(defaultValues.admis, defaultValues.redouble, defaultValues.renvoyer)
+  }
+}
+
+insertDefaultNoteSystemIfNotExist()
+
+async function semestreCreate() {
+  const query = database.prepare('INSERT INTO semestres (nom) VALUES (?)')
+  // Préparation de la requête pour vérifier si une entrée existe déjà
+  const checkSemestreQuery = database.prepare(`
+    SELECT COUNT(*) AS count FROM semestres;
+  `)
+
+  try {
+    let arraySemestre = [
+      'S1',
+      'S2',
+      'S3',
+      'S4',
+      'S5',
+      'S6',
+      'S7',
+      'S8',
+      'S9',
+      'S10',
+      'S11',
+      'S12',
+      'S13',
+      'S14',
+      'S14',
+      'S16'
+    ]
+    // Vérification si une entrée existe déjà
+    const result = checkSemestreQuery.get()
+
+    if (result.count === 0) {
+      database.transaction(() => {
+        for (let index = 0; index < arraySemestre.length; index++) {
+          query.run(arraySemestre[index])
+        }
+      })()
+    }
+  } catch (error) {
+    console.log(error)
+  }
+}
+
+const createNecessaryParameterTable = () => {
+  // Check if the table is empty
+  const rowCount = database.prepare(`SELECT COUNT(*) AS count FROM nessesaryTable`).get().count
+
+  // If the table is empty, insert the default value
+  if (rowCount === 0) {
+    const insertDefaultQuery = `
+      INSERT INTO nessesaryTable (uniter_heure) VALUES (15);
+    `
+    database.prepare(insertDefaultQuery).run()
+  }
+}
+
+// Call the function when the app runs
+createNecessaryParameterTable()
+
+semestreCreate()
+
+// Function to get the IP from the database
+function getIP() {
+  const data = database.prepare("SELECT * FROM ipconfig WHERE id = 1").get();
+
+  if (data) {
+    return data.ipname;
+  } else {
+    return null; // Explicitly return `null` if no data is found
+  }
+}
+
+// Get the new IP from the database
+let newIP = getIP();
+
+if (newIP) {
+  // Construct the database path using the new IP from the database
+  dbPath = `\\\\${newIP}\\base\\data.db`;
+
+  // Reconnect to SQLite database with the updated path
+  database = new sqlite(dbPath); // Re-initialize database connection with new path
+  console.log("now COnnect to the ", dbPath);
+}
+
+module.exports = {
+  database
+}

database/database.js

@@ -1,444 +1,307 @@
-const sqlite = require('better-sqlite3')
+const mysql = require('mysql2/promise')
 const bcrypt = require('bcryptjs')
 
+const pool = mysql.createPool({
+  host: '127.0.0.1',
+  user: 'root',
+  password: '',
+  database: 'university',
+  waitForConnections: true,
+  connectionLimit: 10,
+  queueLimit: 0
+})
 
-// Construct the database path using the detected IP
+async function createTables() {
-let dbPath = `./base/data.db`;
+  const connection = await pool.getConnection()
 
-// Connect to SQLite database with the initial path
+  try {
-let database = new sqlite(dbPath);
+    // Users table
-
+    await connection.query(`
-
-
-
-
-// Create the users table if it doesn't exist
-const createUserTableQuery = `
       CREATE TABLE IF NOT EXISTS users (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         username VARCHAR(200) NOT NULL,
         email VARCHAR(250) NOT NULL UNIQUE,
         password TEXT NOT NULL,
         roles VARCHAR(250) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createUserTableQuery).run()
-
-// Insert a default admin user if not exists
-const insertDefaultUserQuery = `
-  INSERT INTO users (username, email, password, roles)
-  SELECT 'admin', 'admin@example.com', ?, 'admin'
-  WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = 'admin');
-`
-
-// Hash the password '1234' before storing
-const hashedPassword = bcrypt.hashSync('123456789', 10)
-database.prepare(insertDefaultUserQuery).run(hashedPassword)
 
-// create table for note status
+    // Status table
-const createStatusTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS status (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         nom VARCHAR(200) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createStatusTableQuery).run()
 
-// create table for mention
+    // Mentions table
-const createMentionTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS mentions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         nom VARCHAR(250) NOT NULL,
-    uniter VARCHAR(50) NOT NULL, -- Abréviation du nom
+        uniter VARCHAR(50) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createMentionTableQuery).run()
 
-// Create the niveau table if it doesn't exist
+    await connection.query(`
-const createNiveauTableQuery = `
       CREATE TABLE IF NOT EXISTS niveaus (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    nom VARCHAR(50) NOT NULL, -- Exemple: L1, L2, L3, etc.
+        nom VARCHAR(50) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createNiveauTableQuery).run()
 
-// Create the etudiants table if it doesn't exist
+    await connection.query(`
-const createEtudiantsTableQuery = `
       CREATE TABLE IF NOT EXISTS etudiants (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         nom VARCHAR(250) DEFAULT NULL,
         prenom VARCHAR(250) DEFAULT NULL,
         photos TEXT DEFAULT NULL,
         date_de_naissances DATE DEFAULT NULL,
-    niveau VARCHAR(250) NOT NULL, -- Clé étrangère vers niveaus
+        niveau VARCHAR(250) NOT NULL,
         annee_scolaire VARCHAR(20) NOT NULL,
-    status INTEGER DEFAULT NULL,
+        status INT DEFAULT NULL,
-    mention_id INTEGER NOT NULL, -- Clé étrangère vers mentions
+        mention_id INT NOT NULL,
         num_inscription TEXT NOT NULL,
         sexe VARCHAR(20) DEFAULT NULL,
         cin VARCHAR(250) DEFAULT NULL,
-    date_delivrance DEFAULT NULL,
+        date_delivrance DATE DEFAULT NULL,
         nationalite DATE DEFAULT NULL,
         annee_bacc DATE DEFAULT NULL,
         serie VARCHAR(20) DEFAULT NULL,
-    boursier BOOLEAN DEFAULT FALSE,
+        boursier TINYINT(1) DEFAULT 0,
         domaine VARCHAR(250) DEFAULT NULL,
         contact VARCHAR(20) DEFAULT NULL,
         parcours VARCHAR(250) DEFAULT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
         FOREIGN KEY (status) REFERENCES status(id),
         FOREIGN KEY (mention_id) REFERENCES mentions(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createEtudiantsTableQuery).run()
 
-// Create the notes table if it doesn't exist
+    await connection.query(`
-const createMatiereTableQuery = `
       CREATE TABLE IF NOT EXISTS matieres (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         nom VARCHAR(250) UNIQUE NOT NULL,
         unite_enseignement VARCHAR(250) NOT NULL,
-    credit INTEGER NOT NULL,
+        credit INT NOT NULL,
-    heure INTEGER NOT NULL,
+        heure INT NOT NULL,
         ue VARCHAR(10) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createMatiereTableQuery).run()
 
-// Create the semestre table if it doesn't exist
+    await connection.query(`
-const createSemestreTableQuery = `
       CREATE TABLE IF NOT EXISTS semestres (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    nom VARCHAR(30) NOT NULL, -- Exemple: S1, S2, S3, etc.
+        nom VARCHAR(30) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createSemestreTableQuery).run()
 
-// Create the semestre table if it doesn't exist
+    await connection.query(`
-const createMatiere_mentionTableQuery = `
       CREATE TABLE IF NOT EXISTS matiere_mention (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+        matiere_id INT NOT NULL,
-    mention_id INTEGER NOT NULL, -- Clé étrangère vers mentions
+        mention_id INT NOT NULL,
         FOREIGN KEY (matiere_id) REFERENCES matieres(id),
         FOREIGN KEY (mention_id) REFERENCES mentions(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createMatiere_mentionTableQuery).run()
 
-const createMatiere_semestreTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS matiere_semestre (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+        matiere_id INT NOT NULL,
-    semestre_id INTEGER NOT NULL, -- Clé étrangère vers semestres
+        semestre_id INT NOT NULL,
-    mention_id INTEGER NOT NULL, -- Clé étrangère vers niveaus
+        mention_id INT NOT NULL,
         FOREIGN KEY (matiere_id) REFERENCES matieres(id),
         FOREIGN KEY (semestre_id) REFERENCES semestres(id),
         FOREIGN KEY (mention_id) REFERENCES mentions(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createMatiere_semestreTableQuery).run()
 
-// Create the notes table if it doesn't exist
+    await connection.query(`
-const createNoteTableQuery = `
       CREATE TABLE IF NOT EXISTS notes (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
+        etudiant_id INT NOT NULL,
-    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+        matiere_id INT NOT NULL,
         etudiant_niveau VARCHAR(50) NOT NULL,
-    mention_id INTEGER NOT NULL,
+        mention_id INT NOT NULL,
         note FLOAT DEFAULT NULL,
         annee_scolaire VARCHAR(50) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
         FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
-    FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
         FOREIGN KEY (mention_id) REFERENCES mentions(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createNoteTableQuery).run()
 
-// Create the notes second session table if it doesn't exist
+    await connection.query(`
-const createNoteRepechTableQuery = `
       CREATE TABLE IF NOT EXISTS notesrepech (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
+        etudiant_id INT NOT NULL,
-    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
+        matiere_id INT NOT NULL,
         etudiant_niveau VARCHAR(50) NOT NULL,
-    mention_id INTEGER NOT NULL,
+        mention_id INT NOT NULL,
         note FLOAT DEFAULT NULL,
         annee_scolaire VARCHAR(50) NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
         FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
-    FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
         FOREIGN KEY (mention_id) REFERENCES mentions(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createNoteRepechTableQuery).run()
 
-// create table for note système
+    await connection.query(`
-const createNoteSystemeTableQuery = `
       CREATE TABLE IF NOT EXISTS notesystems (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         admis FLOAT NOT NULL DEFAULT 10,
         redouble FLOAT NOT NULL DEFAULT 9.99,
         renvoyer FLOAT NOT NULL DEFAULT 7.99,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createNoteSystemeTableQuery).run()
 
-// create table année scolaire
+    await connection.query(`
-const createAnneeScolaireTableQuery = `
       CREATE TABLE IF NOT EXISTS anneescolaire (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         code VARCHAR(30) NOT NULL,
         debut DATE NOT NULL,
         fin DATE NOT NULL,
-    is_current INTEGER DEFAULT 0,
+        is_current TINYINT(1) DEFAULT 0,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createAnneeScolaireTableQuery).run()
 
-// create traitement systeme
+    await connection.query(`
-const createTraitementSystemQuery = `
       CREATE TABLE IF NOT EXISTS traitmentsystem (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         code VARCHAR(30) NOT NULL,
         debut DATE NOT NULL,
         fin DATE NOT NULL,
-    is_finished INTEGER DEFAULT 0,
+        is_finished TINYINT(1) DEFAULT 0,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createTraitementSystemQuery).run()
 
-const createNecessaryParameterTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS nessesaryTable (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    uniter_heure  INTEGER NOT NULL,
+        uniter_heure INT NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createNecessaryParameterTableQuery).run()
 
-const createMatiereEnseignantTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS matiereEnseignants (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    matiere_id INTEGER NOT NULL,
+        matiere_id INT NOT NULL,
         nom_enseignant VARCHAR(250) NOT NULL,
         prenom_enseignant VARCHAR(250) NOT NULL,
         contact VARCHAR(11) NOT NULL,
         date DATE NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
         FOREIGN KEY (matiere_id) REFERENCES matieres(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createMatiereEnseignantTableQuery).run()
 
-const createParcourTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS parcours (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         nom VARCHAR(250) NOT NULL,
         uniter VARCHAR(250) NOT NULL,
-    mention_id INTEGER DEFAULT NULL, -- Clé étrangère vers mentions
+        mention_id INT DEFAULT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createParcourTableQuery).run()
 
-const createParcourSemestreTableQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS parcoursmatiere (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    matiere_id INTEGER NOT NULL,
+        matiere_id INT NOT NULL,
-    parcour_id INTEGER NOT NULL,
+        parcour_id INT NOT NULL,
         FOREIGN KEY (matiere_id) REFERENCES matieres(id),
         FOREIGN KEY (parcour_id) REFERENCES parcours(id)
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createParcourSemestreTableQuery).run()
 
-const createTableEcolageQuery = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS trancheecolage (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
-    etudiant_id INTEGER NOT NULL,
+        etudiant_id INT NOT NULL,
         tranchename VARCHAR(255) NOT NULL,
         montant DOUBLE NOT NULL
-  );
+      ) ENGINE=InnoDB;
-`
+    `)
-database.prepare(createTableEcolageQuery).run()
 
-const createTableStoreIP = `
+    await connection.query(`
       CREATE TABLE IF NOT EXISTS ipconfig (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+        id INT AUTO_INCREMENT PRIMARY KEY,
         ipname VARCHAR(255) NOT NULL
-  );
+      ) ENGINE=InnoDB;
-`;
-database.prepare(createTableStoreIP).run()
-
-// -------------------------------------- function pre-excuter --------------------------------------------
-
-async function insertStatusesIfNotExist() {
-  // Préparation des requêtes
-  const checkStatusQuery = database.prepare(`
-    SELECT COUNT(*) AS count FROM status WHERE nom = ?;
-  `)
-  const insertStatusQuery = database.prepare(`
-    INSERT INTO status (nom) VALUES (?);
     `)
-
+  } finally {
-  // Tableau des statuts à vérifier/insérer
+    connection.release()
-  const arrayStatus = ['Nouveau', 'Passant', 'Redoublant', 'Renvoyé', 'Ancien']
-
-  for (let index = 0; index < arrayStatus.length; index++) {
-    const statusName = arrayStatus[index]
-
-    // Vérification si le statut existe déjà
-    const result = checkStatusQuery.get(statusName)
-
-    // Si le statut n'existe pas, on l'insère
-    if (result.count === 0) {
-      insertStatusQuery.run(statusName)
-    }
-  }
-}
-// execute the function
-insertStatusesIfNotExist()
-
-async function insertDefaultNoteSystemIfNotExist() {
-  // Préparation de la requête pour vérifier si une entrée existe déjà
-  const checkNoteSystemQuery = database.prepare(`
-    SELECT COUNT(*) AS count FROM notesystems;
-  `)
-
-  // Préparation de la requête pour insérer une entrée par défaut
-  const insertNoteSystemQuery = database.prepare(`
-    INSERT INTO notesystems (admis, redouble, renvoyer)
-    VALUES (?, ?, ?);
-  `)
-
-  // Valeurs par défaut à insérer
-  const defaultValues = {
-    admis: 10.0,
-    redouble: 9.99,
-    renvoyer: 7.99
-  }
-
-  // Vérification si une entrée existe déjà
-  const result = checkNoteSystemQuery.get()
-
-  if (result.count === 0) {
-    // Insérer les valeurs par défaut si aucune entrée n'existe
-    insertNoteSystemQuery.run(defaultValues.admis, defaultValues.redouble, defaultValues.renvoyer)
   }
 }
 
-insertDefaultNoteSystemIfNotExist()
+async function insertDefaultAdmin() {
-
+  const conn = await pool.getConnection()
-async function semestreCreate() {
-  const query = database.prepare('INSERT INTO semestres (nom) VALUES (?)')
-  // Préparation de la requête pour vérifier si une entrée existe déjà
-  const checkSemestreQuery = database.prepare(`
-    SELECT COUNT(*) AS count FROM semestres;
-  `)
-
   try {
-    let arraySemestre = [
+    const [rows] = await conn.query(`SELECT COUNT(*) as count FROM users WHERE username = ?`, [
-      'S1',
+      'admin'
-      'S2',
+    ])
-      'S3',
+    if (rows[0].count === 0) {
-      'S4',
+      const hashedPassword = bcrypt.hashSync('123456789', 10)
-      'S5',
+      await conn.query(
-      'S6',
+        `
-      'S7',
+        INSERT INTO users (username, email, password, roles)
-      'S8',
+        VALUES (?, ?, ?, ?)`,
-      'S9',
+        ['admin', 'admin@example.com', hashedPassword, 'admin']
-      'S10',
+      )
-      'S11',
-      'S12',
-      'S13',
-      'S14',
-      'S14',
-      'S16'
-    ]
-    // Vérification si une entrée existe déjà
-    const result = checkSemestreQuery.get()
-
-    if (result.count === 0) {
-      database.transaction(() => {
-        for (let index = 0; index < arraySemestre.length; index++) {
-          query.run(arraySemestre[index])
-        }
-      })()
     }
-  } catch (error) {
+  } finally {
-    console.log(error)
+    conn.release()
   }
 }
 
-const createNecessaryParameterTable = () => {
+async function insertStatusesIfNotExist() {
-  // Check if the table is empty
+  const conn = await pool.getConnection()
-  const rowCount = database.prepare(`SELECT COUNT(*) AS count FROM nessesaryTable`).get().count
+  try {
-
+    const statuses = ['Nouveau', 'Passant', 'Redoublant', 'Renvoyé', 'Ancien']
-  // If the table is empty, insert the default value
+    for (let name of statuses) {
-  if (rowCount === 0) {
+      const [rows] = await conn.query(`SELECT COUNT(*) as count FROM status WHERE nom = ?`, [name])
-    const insertDefaultQuery = `
+      if (rows[0].count === 0) {
-      INSERT INTO nessesaryTable (uniter_heure) VALUES (15);
+        await conn.query(`INSERT INTO status (nom) VALUES (?)`, [name])
-    `
-    database.prepare(insertDefaultQuery).run()
       }
     }
-
+  } finally {
-// Call the function when the app runs
+    conn.release()
-createNecessaryParameterTable()
-
-semestreCreate()
-
-// Function to get the IP from the database
-function getIP() {
-  const data = database.prepare("SELECT * FROM ipconfig WHERE id = 1").get();
-
-  if (data) {
-    return data.ipname;
-  } else {
-    return null; // Explicitly return `null` if no data is found
-  }
   }
-
-// Get the new IP from the database
-let newIP = getIP();
-
-if (newIP) {
-  // Construct the database path using the new IP from the database
-  dbPath = `\\\\${newIP}\\base\\data.db`;
-
-  // Reconnect to SQLite database with the updated path
-  database = new sqlite(dbPath); // Re-initialize database connection with new path
-  console.log("now COnnect to the ", dbPath);
 }
 
 module.exports = {
-  database
+  pool,
+  createTables,
+  insertDefaultAdmin,
+  insertStatusesIfNotExist
 }

database/database2.js

@@ -0,0 +1,307 @@
+const mysql = require('mysql2/promise')
+const bcrypt = require('bcryptjs')
+
+const pool = mysql.createPool({
+  host: '127.0.0.1',
+  user: 'root',
+  password: '',
+  database: 'university',
+  waitForConnections: true,
+  connectionLimit: 10,
+  queueLimit: 0
+})
+
+async function createTables() {
+  const connection = await pool.getConnection()
+
+  try {
+    // Users table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        username VARCHAR(200) NOT NULL,
+        email VARCHAR(250) NOT NULL UNIQUE,
+        password TEXT NOT NULL,
+        roles VARCHAR(250) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    // Status table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS status (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(200) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    // Mentions table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS mentions (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(250) NOT NULL,
+        uniter VARCHAR(50) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS niveaus (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(50) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS etudiants (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(250) DEFAULT NULL,
+        prenom VARCHAR(250) DEFAULT NULL,
+        photos TEXT DEFAULT NULL,
+        date_de_naissances DATE DEFAULT NULL,
+        niveau VARCHAR(250) NOT NULL,
+        annee_scolaire VARCHAR(20) NOT NULL,
+        status INT DEFAULT NULL,
+        mention_id INT NOT NULL,
+        num_inscription TEXT NOT NULL,
+        sexe VARCHAR(20) DEFAULT NULL,
+        cin VARCHAR(250) DEFAULT NULL,
+        date_delivrance DATE DEFAULT NULL,
+        nationalite DATE DEFAULT NULL,
+        annee_bacc DATE DEFAULT NULL,
+        serie VARCHAR(20) DEFAULT NULL,
+        boursier TINYINT(1) DEFAULT 0,
+        domaine VARCHAR(250) DEFAULT NULL,
+        contact VARCHAR(20) DEFAULT NULL,
+        parcours VARCHAR(250) DEFAULT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        FOREIGN KEY (status) REFERENCES status(id),
+        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS matieres (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(250) UNIQUE NOT NULL,
+        unite_enseignement VARCHAR(250) NOT NULL,
+        credit INT NOT NULL,
+        heure INT NOT NULL,
+        ue VARCHAR(10) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS semestres (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(30) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS matiere_mention (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        matiere_id INT NOT NULL,
+        mention_id INT NOT NULL,
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS matiere_semestre (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        matiere_id INT NOT NULL,
+        semestre_id INT NOT NULL,
+        mention_id INT NOT NULL,
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+        FOREIGN KEY (semestre_id) REFERENCES semestres(id),
+        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS notes (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        etudiant_id INT NOT NULL,
+        matiere_id INT NOT NULL,
+        etudiant_niveau VARCHAR(50) NOT NULL,
+        mention_id INT NOT NULL,
+        note FLOAT DEFAULT NULL,
+        annee_scolaire VARCHAR(50) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS notesrepech (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        etudiant_id INT NOT NULL,
+        matiere_id INT NOT NULL,
+        etudiant_niveau VARCHAR(50) NOT NULL,
+        mention_id INT NOT NULL,
+        note FLOAT DEFAULT NULL,
+        annee_scolaire VARCHAR(50) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS notesystems (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        admis FLOAT NOT NULL DEFAULT 10,
+        redouble FLOAT NOT NULL DEFAULT 9.99,
+        renvoyer FLOAT NOT NULL DEFAULT 7.99,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS anneescolaire (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        code VARCHAR(30) NOT NULL,
+        debut DATE NOT NULL,
+        fin DATE NOT NULL,
+        is_current TINYINT(1) DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS traitmentsystem (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        code VARCHAR(30) NOT NULL,
+        debut DATE NOT NULL,
+        fin DATE NOT NULL,
+        is_finished TINYINT(1) DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS nessesaryTable (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        uniter_heure INT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS matiereEnseignants (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        matiere_id INT NOT NULL,
+        nom_enseignant VARCHAR(250) NOT NULL,
+        prenom_enseignant VARCHAR(250) NOT NULL,
+        contact VARCHAR(11) NOT NULL,
+        date DATE NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS parcours (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        nom VARCHAR(250) NOT NULL,
+        uniter VARCHAR(250) NOT NULL,
+        mention_id INT DEFAULT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS parcoursmatiere (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        matiere_id INT NOT NULL,
+        parcour_id INT NOT NULL,
+        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+        FOREIGN KEY (parcour_id) REFERENCES parcours(id)
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS trancheecolage (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        etudiant_id INT NOT NULL,
+        tranchename VARCHAR(255) NOT NULL,
+        montant DOUBLE NOT NULL
+      ) ENGINE=InnoDB;
+    `)
+
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS ipconfig (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        ipname VARCHAR(255) NOT NULL
+      ) ENGINE=InnoDB;
+    `)
+  } finally {
+    connection.release()
+  }
+}
+
+async function insertDefaultAdmin() {
+  const conn = await pool.getConnection()
+  try {
+    const [rows] = await conn.query(`SELECT COUNT(*) as count FROM users WHERE username = ?`, [
+      'admin'
+    ])
+    if (rows[0].count === 0) {
+      const hashedPassword = bcrypt.hashSync('123456789', 10)
+      await conn.query(
+        `
+        INSERT INTO users (username, email, password, roles)
+        VALUES (?, ?, ?, ?)`,
+        ['admin', 'admin@example.com', hashedPassword, 'admin']
+      )
+    }
+  } finally {
+    conn.release()
+  }
+}
+
+async function insertStatusesIfNotExist() {
+  const conn = await pool.getConnection()
+  try {
+    const statuses = ['Nouveau', 'Passant', 'Redoublant', 'Renvoyé', 'Ancien']
+    for (let name of statuses) {
+      const [rows] = await conn.query(`SELECT COUNT(*) as count FROM status WHERE nom = ?`, [name])
+      if (rows[0].count === 0) {
+        await conn.query(`INSERT INTO status (nom) VALUES (?)`, [name])
+      }
+    }
+  } finally {
+    conn.release()
+  }
+}
+
+module.exports = {
+  pool,
+  createTables,
+  insertDefaultAdmin,
+  insertStatusesIfNotExist
+}

jsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "jsx": "react-jsx",
+    "allowImportingTsExtensions": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true
+  },
+  "exclude": [
+    "node_modules",
+    "**/node_modules/*"
+  ]
+}

package.json

@@ -36,6 +36,7 @@
     "@emotion/styled": "^11.13.0",
     "@mui/material": "^6.1.1",
     "@mui/x-data-grid": "^7.18.0",
+    "@tanstack/react-query": "^5.83.0",
     "ag-psd": "^22.0.2",
     "axios": "^1.9.0",
     "bcryptjs": "^2.4.3",
@@ -52,6 +53,7 @@
     "html2canvas": "^1.4.1",
     "jspdf": "^2.5.2",
     "jspdf-autotable": "^5.0.2",
+    "mysql2": "^3.14.2",
     "papaparse": "^5.4.1",
     "pdf-lib": "^1.17.1",
     "qrcode": "^1.5.4",

src/main/backup.js

@@ -1,31 +1,121 @@
-import { app, shell, BrowserWindow, ipcMain, Tray } from 'electron'
+import { app, shell, BrowserWindow, ipcMain, Tray, Menu } from 'electron'
 import { join } from 'path'
+const path = require('path')
 import { electronApp, optimizer, is } from '@electron-toolkit/utils'
-import icon from '../../resources/icon.png?asset'
+import icon from '../../resources/logo.ico?asset' // Your tray icon file
+const database = require('../../database/database2')
+
+database
+  .createTables()
+  .then(() => database.insertDefaultAdmin())
+  .then(() => database.insertStatusesIfNotExist())
+  .catch(console.error)
+
+const { createConfigIp, updateIPConfig } = require('../../database/Models/IpConfig')
+const { importFileToDatabase } = require('../../database/import/Etudiants')
 const { loginUser, forgotPassword, insertUser, updateUser } = require('../../database/Models/Users')
 const {
   insertEtudiant,
   getSingleEtudiant,
   FilterDataByNiveau,
-  updateEtudiant
+  updateEtudiant,
+  changePDP,
+  updateParcours,
+  createTranche,
+  getTranche,
+  updateTranche,
+  deleteTranche,
+  getSingleTranche
 } = require('../../database/Models/Etudiants')
-const { insertNiveau } = require('../../database/Models/Niveau')
+const {
-const { insertNote } = require('../../database/Models/Notes')
+  insertNiveau,
-
+  updateNiveau,
-// declare mainWindow in the global scope
+  getSingleNiveau,
+  deleteNiveau
+} = require('../../database/Models/Niveau')
+const {
+  insertNote,
+  getNote,
+  updateNote,
+  showMoyen,
+  getMatiereAndNote,
+  getNotesWithRepechToDisplay
+} = require('../../database/Models/Notes')
+const {
+  createMatiere,
+  getSingleMatiere,
+  updateMatiere,
+  displayMatiereFromForm,
+  deleteMatiere,
+  asygnationToMention,
+  getMentionMatiere,
+  getMentionMatiereChecked,
+  getSemestreMatiere,
+  insertUpdateMentionSemestre,
+  insertNewProf,
+  getSIngleProf,
+  updateProf
+} = require('../../database/Models/Matieres')
+const { importFileToDatabaseMatiere } = require('../../database/import/Matieres')
+const { importNiveau } = require('../../database/import/Niveau')
+const { updateSysteme } = require('../../database/Models/NoteSysrem')
+const {
+  createAnneeScolaire,
+  deleteAnneeScolaire,
+  getSingleAnneScolaire,
+  updateAnneeScolaire,
+  setCurrent
+} = require('../../database/Models/AnneeScolaire')
+const {
+  createMention,
+  deleteMention,
+  getSingleMention,
+  updateMention
+} = require('../../database/Models/Mentions')
+const {
+  getNoteRepech,
+  updateNoteRepech,
+  showMoyenRepech
+} = require('../../database/Models/NoteRepechage')
+const {
+  updateCurrentYears,
+  updateStudents,
+  updateNessesaryTable
+} = require('../../database/function/System')
+const { autoUpdater } = require('electron-updater')
+const { URL } = require('../../database/api/Config')
+const {
+  insertParcour,
+  getSingleParcours,
+  deletes,
+  updateparcour,
+  parcourMatiere,
+  extractFiche,
+  getParcourMatiere
+} = require('../../database/Models/Parcours')
+
+// Declare mainWindow and tray in the global scope
 let mainWindow
 let tray = null
+updateCurrentYears()
+updateStudents()
+
+autoUpdater.setFeedURL({
+  provider: 'generic',
+  url: `${URL}/latest` // Ensure this points to the folder containing latest.yml
+})
 
 function createWindow() {
   // Create the browser window.
   mainWindow = new BrowserWindow({
-    width: 1000,
+    width: 1375,
-    minWidth: 1000,
+    minWidth: 1375,
-    height: 670,
+    height: 740,
-    minHeight: 670,
+    minHeight: 740,
     show: false,
     autoHideMenuBar: true,
-    fullscreen: true, // This will make the window fullscreen when opened
+    fullscreen: false,
+    icon: path.join(__dirname, 'resources', 'logo.ico'), // Path to your icon,
     ...(process.platform === 'linux' ? { icon } : {}),
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
@@ -35,7 +125,15 @@ function createWindow() {
     }
   })
 
+  // Désactiver les raccourcis clavier
+  mainWindow.webContents.on('before-input-event', (event, input) => {
+    if (input.control || input.meta || input.alt || input.key === 'F11') {
+      event.preventDefault()
+    }
+  })
+
   mainWindow.on('ready-to-show', () => {
+    mainWindow.maximize() // Maximiser la fenêtre
     mainWindow.show()
   })
 
@@ -44,44 +142,134 @@ function createWindow() {
     return { action: 'deny' }
   })
 
-  // HMR for renderer base on electron-vite cli.
+  // Load the appropriate URL based on environment
-  // Load the remote URL for development or the local html file for production.
   if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
     mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL'])
   } else {
     mainWindow.loadFile(join(__dirname, '../renderer/index.html'))
   }
+
+  // Handle window close (hide instead of closing)
+  mainWindow.on('close', (event) => {
+    if (!app.isQuiting) {
+      event.preventDefault()
+      mainWindow.hide() // Minimize to tray instead of closing
+    } else {
+      // Destroy the tray when quitting
+      if (tray) tray.destroy()
+    }
+  })
+}
+
+// Function to create the system tray
+function createTray() {
+  const iconPath = icon // Use your icon path here
+  tray = new Tray(iconPath)
+
+  // Create a context menu for the tray
+  const contextMenu = Menu.buildFromTemplate([
+    {
+      label: 'Ouvrir',
+      click: () => {
+        mainWindow.show()
+        mainWindow.webContents.send('navigateToRoute', '#/') // Send the route as a string
+      }
+    },
+    {
+      label: 'A Propos',
+      click: () => {
+        mainWindow.show()
+        mainWindow.webContents.send('navigateToRoute', '#/apropos') // Send the route as a string
+      }
+    },
+    {
+      label: 'Quit',
+      click: () => {
+        // Clear localStorage in the renderer process
+        mainWindow.webContents
+          .executeJavaScript('localStorage.removeItem("ACCESS_TOKEN");')
+          .then(() => {
+            console.log('localStorage cleared.')
+            // Ensure the app quits entirely
+            if (tray) {
+              app.quit()
+              tray.destroy()
+              // if (app.quit()) {
+              //   tray.destroy()
+              // }
+            } // Quit the app
+          })
+          .catch((err) => {
+            console.error('Error clearing localStorage:', err)
+            // Quit the app even if clearing fails
+            if (tray) {
+              app.quit()
+              tray.destroy()
+              // if (app.quit()) {
+              //   tray.destroy()
+              // }
+            }
+          })
+      }
+    }
+  ])
+
+  tray.setToolTip('My Electron App')
+  tray.setContextMenu(contextMenu)
+
+  // Show the app when the tray icon is clicked
+  tray.on('click', () => {
+    mainWindow.show()
+  })
 }
 
-// This method will be called when Electron has finished
-// initialization and is ready to create browser windows.
-// Some APIs can only be used after this event occurs.
 app.whenReady().then(() => {
-  // Set app user model id for windows
   electronApp.setAppUserModelId('com.electron')
+  autoUpdater.checkForUpdatesAndNotify()
 
-  // Default open or close DevTools by F12 in development
-  // and ignore CommandOrControl + R in production.
-  // see https://github.com/alex8088/electron-toolkit/tree/master/packages/utils
   app.on('browser-window-created', (_, window) => {
     optimizer.watchWindowShortcuts(window)
   })
 
-  // IPC test
-  ipcMain.on('pingpong', () => console.log('pongsss'))
-
   createWindow()
+  createTray() // Create the tray icon
 
   app.on('activate', function () {
-    // On macOS it's common to re-create a window in the app when the
-    // dock icon is clicked and there are no other windows open.
     if (BrowserWindow.getAllWindows().length === 0) createWindow()
   })
 })
 
-// Quit when all windows are closed, except on macOS. There, it's common
+// When an update is available
-// for applications and their menu bar to stay active until the user quits
+autoUpdater.on('update-available', () => {
-// explicitly with Cmd + Q.
+  dialog.showMessageBox({
+    type: 'info',
+    title: 'Mise à jour disponible',
+    message: 'Une nouvelle version est disponible. Téléchargement en cours...'
+  })
+})
+
+// When the update is downloaded
+autoUpdater.on('update-downloaded', (info) => {
+  dialog
+    .showMessageBox({
+      type: 'info',
+      title: 'Mise à jour prête',
+      message: `La version ${info.version} a été téléchargée. Redémarrer maintenant ?`,
+      buttons: ['Redémarrer', 'Plus tard']
+    })
+    .then((result) => {
+      if (result.response === 0) {
+        autoUpdater.quitAndInstall()
+      }
+    })
+})
+
+// If an error occurs
+autoUpdater.on('error', (error) => {
+  dialog.showErrorBox('Update Error', error == null ? 'Unknown' : error.message)
+})
+
+// Quit the app when all windows are closed, except on macOS
 app.on('window-all-closed', () => {
   if (process.platform !== 'darwin') {
     app.quit()
@@ -126,9 +314,9 @@ ipcMain.handle('forgotPassword', async (event, credentials) => {
 
 // event for updating users
 ipcMain.handle('updateUsers', async (event, credentials) => {
-  const { username, email, passwordVerif, password, id } = credentials
+  const { username, newUsername, email, newEmail, passwordVerif, password, id } = credentials
 
-  const update = await updateUser(username, email, password, id)
+  const update = await updateUser(newUsername, newEmail, password, id)
 
   return update
 })
@@ -147,8 +335,27 @@ ipcMain.handle('minimize', async () => {
 
 // event for insert etudiants
 ipcMain.handle('insertEtudiant', async (event, credentials) => {
-  const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription } =
+  const {
-    credentials
+    nom,
+    prenom,
+    photos,
+    date_de_naissances,
+    niveau,
+    annee_scolaire,
+    status,
+    num_inscription,
+    mention_id,
+    sexe,
+    nationaliter,
+    cin,
+    date_delivrence,
+    annee_bacc,
+    serie,
+    boursier,
+    domaine,
+    contact,
+    parcours
+  } = credentials
 
   const insert = await insertEtudiant(
     nom,
@@ -157,7 +364,19 @@ ipcMain.handle('insertEtudiant', async (event, credentials) => {
     date_de_naissances,
     niveau,
     annee_scolaire,
-    num_inscription
+    status,
+    num_inscription,
+    mention_id,
+    sexe,
+    nationaliter,
+    cin,
+    date_delivrence,
+    annee_bacc,
+    serie,
+    boursier,
+    domaine,
+    contact,
+    parcours
   )
 
   return insert
@@ -192,8 +411,28 @@ ipcMain.handle('insertNiveau', async (event, credentials) => {
 
 // event for updating etudiants
 ipcMain.handle('updateETudiants', async (event, credentials) => {
-  const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription, id } =
+  const {
-    credentials
+    nom,
+    prenom,
+    photos,
+    date_de_naissances,
+    niveau,
+    annee_scolaire,
+    status,
+    mention_id,
+    num_inscription,
+    id,
+    sexe,
+    nationalite,
+    cin,
+    date_delivrance,
+    annee_bacc,
+    serie,
+    boursier,
+    domaine,
+    contact,
+    parcours
+  } = credentials
 
   const updating = await updateEtudiant(
     nom,
@@ -202,54 +441,472 @@ ipcMain.handle('updateETudiants', async (event, credentials) => {
     date_de_naissances,
     niveau,
     annee_scolaire,
+    status,
+    mention_id,
     num_inscription,
-    id
+    id,
+    sexe,
+    nationalite,
+    cin,
+    date_delivrance,
+    annee_bacc,
+    serie,
+    boursier,
+    domaine,
+    contact,
+    parcours
   )
 
   return updating
 })
 
+// event for updating etudiants pdp
+ipcMain.handle('updateETudiantsPDP', async (event, credentials) => {
+  const { pdp, id } = credentials
+
+  const updating = await changePDP(pdp, id)
+
+  return updating
+})
+
 // event for adding notes
 ipcMain.handle('insertNote', async (event, credentials) => {
-  const {
+  const { etudiant_id, etudiant_niveau, mention_id, formData, annee_scolaire } = credentials
-    etudiant_id,
-    Algebre,
-    Analyse,
-    Mecanique_Generale_I,
-    Resistance_Materiaux,
-    Electricite,
-    Chimie_Generale_1,
-    Algorithmique,
-    Thermodynamique_Physique,
-    Mecanique_Fluide,
-    Optique_Geometrique,
-    Calcul_Numerique,
-    Calcul_Vectoriel_Integral,
-    Francais,
-    Anglais,
-    Dessin_Technique,
-    Programmation
-  } = credentials
 
   const insert = await insertNote(
     etudiant_id,
-    Algebre,
+    etudiant_niveau,
-    Analyse,
+    mention_id,
-    Mecanique_Generale_I,
+    formData,
-    Resistance_Materiaux,
+    annee_scolaire
-    Electricite,
-    Chimie_Generale_1,
-    Algorithmique,
-    Thermodynamique_Physique,
-    Mecanique_Fluide,
-    Optique_Geometrique,
-    Calcul_Numerique,
-    Calcul_Vectoriel_Integral,
-    Francais,
-    Anglais,
-    Dessin_Technique,
-    Programmation
   )
 
   return insert
 })
+
+// event for get single note
+ipcMain.handle('getSingleNote', async (event, credentials) => {
+  const { id, niveau, mention_id } = credentials
+
+  const get = await getNote(id, niveau, mention_id)
+
+  return get
+})
+
+// event for get single note repech
+ipcMain.handle('getNotesRepech', async (event, credentials) => {
+  const { id, niveau, mention_id } = credentials
+
+  const get = await getNoteRepech(id, niveau, mention_id)
+
+  return get
+})
+
+// event for updating note
+ipcMain.handle('updatetNote', async (event, credentials) => {
+  const { formData, niveau, id, mention_id, annee_scolaire } = credentials
+
+  const update = await updateNote(formData, niveau, id, mention_id, annee_scolaire)
+
+  return update
+})
+
+// event for updating note repech
+ipcMain.handle('updatetNoteRepech', async (event, credentials) => {
+  const { formData2, niveau, id } = credentials
+
+  const update = await updateNoteRepech(formData2, niveau, id)
+
+  return update
+})
+
+// event to get single matiere
+ipcMain.handle('getMatiereByID', async (event, credentials) => {
+  const { id } = credentials
+
+  const matiere = await getSingleMatiere(id)
+
+  return matiere
+})
+
+// event for updating matiere
+ipcMain.handle('updateMatiere', async (event, credentials) => {
+  const { nom, credit, uniter, ue, id } = credentials
+
+  const update = await updateMatiere(nom, id, credit, uniter, ue)
+
+  return update
+})
+// event for importExcel
+ipcMain.handle('importexcel', async (event, credentials) => {
+  const files = credentials
+  console.log(files)
+  const insert = await importFileToDatabase(files)
+
+  return insert
+})
+
+// event for udatign a single niveau
+ipcMain.handle('updateSingleNiveau', async (event, credentials) => {
+  const { nom, id } = credentials
+
+  const update = updateNiveau(nom, id)
+
+  return update
+})
+
+// event to get single niveau
+ipcMain.handle('singleNiveau', async (event, credentials) => {
+  const { id } = credentials
+
+  const update = getSingleNiveau(id)
+
+  return update
+})
+
+// event for creating matiere
+ipcMain.handle('createMatiere', async (event, credentials) => {
+  const { nom, credit, uniter, ue } = credentials
+
+  const create = createMatiere(nom, credit, uniter, ue)
+
+  return create
+})
+
+// event for import excel matiere
+ipcMain.handle('importExcelMatiere', async (event, credentials) => {
+  const files = credentials
+  console.log(files)
+  const insert = await importFileToDatabaseMatiere(files)
+
+  return insert
+})
+
+// event for import excel niveau
+ipcMain.handle('importNiveau', async (event, credentials) => {
+  const files = credentials
+  console.log(files)
+  const insert = await importNiveau(files)
+
+  return insert
+})
+
+// event for updating note systeme
+ipcMain.handle('updateNoteSysteme', async (event, credentials) => {
+  const { id, admis, redouble, renvoyer } = credentials
+
+  const update = updateSysteme(id, admis, redouble, renvoyer)
+  return update
+})
+
+// event for updating note systeme
+ipcMain.handle('createAnneeScolaire', async (event, credentials) => {
+  const { code, debut, fin } = credentials
+
+  const create = createAnneeScolaire(code, debut, fin)
+  return create
+})
+
+ipcMain.handle('getMoyene', async (event, credentials) => {
+  const { niveau, scolaire } = credentials
+  console.log('index.js', niveau, scolaire)
+
+  const create = showMoyen(niveau, scolaire)
+  return create
+})
+
+ipcMain.handle('getMoyenneRepech', async (event, credentials) => {
+  const { niveau, scolaire } = credentials
+  console.log('index.js', niveau, scolaire)
+
+  const create = showMoyenRepech(niveau, scolaire)
+  return create
+})
+
+ipcMain.handle('noteMatiere', async (event, credentials) => {
+  const { id, niveau, annee_scolaire } = credentials
+
+  const get = getMatiereAndNote(id, niveau, annee_scolaire)
+  return get
+})
+
+ipcMain.handle('displayMatiereFromForm', async (event, credentials) => {
+  const { niveau, mention_id, parcours } = credentials
+
+  const get = displayMatiereFromForm(niveau, mention_id, parcours)
+  return get
+})
+
+ipcMain.handle('createMention', async (event, credentials) => {
+  const { nom, uniter } = credentials
+
+  const get = createMention(nom, uniter)
+  return get
+})
+
+ipcMain.handle('getSingleMention', async (event, credentials) => {
+  const { id } = credentials
+
+  const get = getSingleMention(id)
+  return get
+})
+
+ipcMain.handle('updateMention', async (event, credentials) => {
+  const { nom, uniter, id } = credentials
+
+  const get = updateMention(nom, uniter, id)
+  return get
+})
+
+ipcMain.handle('deleteMention', async (event, credentials) => {
+  const { id } = credentials
+
+  const get = deleteMention(id)
+  return get
+})
+
+ipcMain.handle('deleteNiveaus', async (event, credentials) => {
+  const { id } = credentials
+
+  const get = deleteNiveau(id)
+  return get
+})
+
+ipcMain.handle('deleteMatiere', async (event, credentials) => {
+  const { id } = credentials
+
+  const get = deleteMatiere(id)
+  return get
+})
+
+ipcMain.handle('asign', async (event, credentials) => {
+  const { formData, id } = credentials
+  // console.log(formData, id);
+  const get = asygnationToMention(formData, id)
+
+  return get
+})
+
+ipcMain.handle('asignSemestre', async (event, credentials) => {
+  const { id } = credentials
+
+  const get = getMentionMatiereChecked(id)
+
+  return get
+})
+
+ipcMain.handle('getAsign', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getMentionMatiere(id)
+
+  return get
+})
+
+ipcMain.handle('deleteAnneeScolaire', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = deleteAnneeScolaire(id)
+
+  return get
+})
+
+ipcMain.handle('getSemestreMatiere', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getSemestreMatiere(id)
+
+  return get
+})
+
+ipcMain.handle('insertUpdateMentionSemestre', async (event, credentials) => {
+  const { id, selectedSemestres } = credentials
+  // console.log(formData, id);
+  const get = insertUpdateMentionSemestre(id, selectedSemestres)
+
+  return get
+})
+
+ipcMain.handle('getSingleAnneeScolaire', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getSingleAnneScolaire(id)
+
+  return get
+})
+
+ipcMain.handle('updateAnneeScolaire', async (event, credentials) => {
+  const { code, debut, fin, id } = credentials
+  // console.log(formData, id);
+  const get = updateAnneeScolaire(id, code, debut, fin)
+
+  return get
+})
+
+ipcMain.handle('setCurrent', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = setCurrent(id)
+
+  return get
+})
+
+ipcMain.handle('noteRelerer', async (event, credentials) => {
+  const { id, anneescolaire, niveau } = credentials
+  // console.log(formData, id);
+  const get = getNotesWithRepechToDisplay(id, anneescolaire, niveau)
+
+  return get
+})
+
+ipcMain.handle('updateNessesary', async (event, credentials) => {
+  const { id, multiplicateur } = credentials
+  // console.log(formData, id);
+  const get = updateNessesaryTable(id, multiplicateur)
+
+  return get
+})
+
+ipcMain.handle('insertProf', async (event, credentials) => {
+  const { nom_enseignant, prenom_enseignant, contact, date, matiere_id } = credentials
+  // console.log(formData, id);
+  const get = insertNewProf(matiere_id, nom_enseignant, prenom_enseignant, contact, date)
+
+  return get
+})
+
+ipcMain.handle('insertParcours', async (event, credentials) => {
+  const { nom, uniter, mention_id } = credentials
+  // console.log(formData, id);
+  const get = insertParcour(nom, uniter, mention_id)
+
+  return get
+})
+
+ipcMain.handle('getSingleParcours', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getSingleParcours(id)
+
+  return get
+})
+
+ipcMain.handle('deleteParcours', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = deletes(id)
+
+  return get
+})
+
+ipcMain.handle('updateParcours', async (event, credentials) => {
+  const { nom, uniter, mention_id, id } = credentials
+  // console.log(formData, id);
+  const get = updateparcour(id, nom, uniter, mention_id)
+
+  return get
+})
+
+ipcMain.handle('parcourMatiere', async (event, credentials) => {
+  const { matiere_id, parcour_id } = credentials
+  // console.log(formData, id);
+  const get = parcourMatiere(matiere_id, parcour_id)
+
+  return get
+})
+
+ipcMain.handle('getSingleProf', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getSIngleProf(id)
+
+  return get
+})
+
+ipcMain.handle('updateProf', async (event, credentials) => {
+  const { nom_enseignant, prenom_enseignant, contact, date, matiere_id } = credentials
+  // console.log(formData, id);
+  const get = updateProf(matiere_id, nom_enseignant, prenom_enseignant, contact, date)
+
+  return get
+})
+
+ipcMain.handle('extractFiches', async (event, credentials) => {
+  const { matiere_id } = credentials
+  // console.log(formData, id);
+  const get = extractFiche(matiere_id)
+
+  return get
+})
+
+ipcMain.handle('getParcourMatiere', async (event, credentials) => {
+  const { matiere_id } = credentials
+  // console.log(formData, id);
+  const get = getParcourMatiere(matiere_id)
+
+  return get
+})
+
+ipcMain.handle('changeParcours', async (event, credentials) => {
+  const { parcours, user_id } = credentials
+  // console.log(formData, id);
+  const get = updateParcours(parcours, user_id)
+
+  return get
+})
+
+ipcMain.handle('createTranche', async (event, credentials) => {
+  const { etudiant_id, tranchename, montant } = credentials
+  // console.log(formData, id);
+  const get = createTranche(etudiant_id, tranchename, montant)
+
+  return get
+})
+
+ipcMain.handle('getTranche', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getTranche(id)
+
+  return get
+})
+
+ipcMain.handle('updateTranche', async (event, credentials) => {
+  const { id, tranchename, montant } = credentials
+  // console.log(formData, id);
+  const get = updateTranche(id, tranchename, montant)
+
+  return get
+})
+
+ipcMain.handle('deleteTranche', async (event, credentials) => {
+  const { id } = credentials
+  console.log(id)
+  const get = deleteTranche(id)
+
+  return get
+})
+
+ipcMain.handle('getSingleTranche', async (event, credentials) => {
+  const { id } = credentials
+  // console.log(formData, id);
+  const get = getSingleTranche(id)
+
+  return get
+})
+
+ipcMain.handle('createIPConfig', async (event, credentials) => {
+  const { ipname } = credentials
+  // console.log(formData, id);
+  const get = createConfigIp(ipname)
+
+  return get
+})
+
+ipcMain.handle('updateIPConfig', async (event, credentials) => {
+  const { id, ipname } = credentials
+  // console.log(formData, id);
+  const get = updateIPConfig(id, ipname)
+
+  return get
+})

src/preload/index.backup.js

@@ -0,0 +1,210 @@
+import { contextBridge, ipcRenderer } from 'electron'
+import { electronAPI } from '@electron-toolkit/preload'
+const { getNessesarytable } = require('../../database/function/System')
+const { getNiveau } = require('../../database/Models/Niveau')
+const { getAllUsers } = require('../../database/Models/Users')
+const { getAllEtudiants, getDataToDashboard } = require('../../database/Models/Etudiants')
+const { verifyEtudiantIfHeHasNotes, blockShowMoyene } = require('../../database/Models/Notes')
+
+const { synchronizeData } = require('../../database/api/SyncronisationDataUsers')
+const { synchronizeDataEtudiants } = require('../../database/api/SyncronisationDataEtudiants')
+const { synchronizeDataNotes } = require('../../database/api/CheckUpdateNote')
+const { getMatiere, getSemestre, getEnseignants } = require('../../database/Models/Matieres')
+const { getSysteme } = require('../../database/Models/NoteSysrem')
+const { getStatus } = require('../../database/Models/Status')
+const { getAnneeScolaire, getInterval } = require('../../database/Models/AnneeScolaire')
+const { getMentions } = require('../../database/Models/Mentions')
+const { getAll } = require('../../database/api/Get')
+const { getParcours } = require('../../database/Models/Parcours')
+const { getIPConfig } = require('../../database/Models/IpConfig')
+
+// Custom APIs for renderer
+const api = {}
+
+// Use `contextBridge` APIs to expose Electron APIs to
+// renderer only if context isolation is enabled, otherwise
+// just add to the DOM global.
+if (process.contextIsolated) {
+  try {
+    contextBridge.exposeInMainWorld('electron', electronAPI)
+    contextBridge.exposeInMainWorld('api', api)
+
+    /**
+     * contextBridge for Tray
+     */
+    contextBridge.exposeInMainWorld('Tray', {
+      onNavigate: (callback) => {
+        ipcRenderer.on('navigateToRoute', (event, route) => {
+          callback(route) // Pass the route to the renderer callback
+        })
+      }
+    })
+
+    /**
+     * contextBridge for users
+     */
+    contextBridge.exposeInMainWorld('allUser', {
+      users: () => getAllUsers(),
+      login: (credentials) => ipcRenderer.invoke('login', credentials),
+      insertUsers: (credentials) => ipcRenderer.invoke('insertUser', credentials),
+      forgotPassword: (credentials) => ipcRenderer.invoke('forgotPassword', credentials),
+      quit: () => ipcRenderer.invoke('quit'),
+      minimize: () => ipcRenderer.invoke('minimize'),
+      updateUsers: (credentials) => ipcRenderer.invoke('updateUsers', credentials)
+    })
+
+    contextBridge.exposeInMainWorld('syncro', {
+      getall: () => getAll()
+    })
+
+    // syncronisation des donner
+    window.addEventListener('online', async () => {
+      if (navigator.onLine) {
+        // synchronizeData()
+        // synchronizeDataEtudiants()
+        // synchronizeDataNotes()
+        await getAll()
+      }
+    })
+    // send data
+    getAll()
+
+    /**
+     * contextBridge for etudiants
+     */
+    contextBridge.exposeInMainWorld('etudiants', {
+      insertEtudiant: (credentials) => ipcRenderer.invoke('insertEtudiant', credentials),
+      getEtudiants: () => getAllEtudiants(),
+      FilterDataByNiveau: (credential) => ipcRenderer.invoke('getByNiveau', credential),
+      getSingle: (credential) => ipcRenderer.invoke('single', credential),
+      updateEtudiants: (credentials) => ipcRenderer.invoke('updateETudiants', credentials),
+      getDataToDashboards: () => getDataToDashboard(),
+      updateEtudiantsPDP: (credentials) => ipcRenderer.invoke('updateETudiantsPDP', credentials),
+      importExcel: (credentials) => ipcRenderer.invoke('importexcel', credentials),
+      changeParcours: (credentials) => ipcRenderer.invoke('changeParcours', credentials),
+      createTranche: (credentials) => ipcRenderer.invoke('createTranche', credentials),
+      getTranche: (credentials) => ipcRenderer.invoke('getTranche', credentials),
+      updateTranche: (credentials) => ipcRenderer.invoke('updateTranche', credentials),
+      deleteTranche: (credentials) => ipcRenderer.invoke('deleteTranche', credentials),
+      getSingleTranche: (credentials) => ipcRenderer.invoke('getSingleTranche', credentials)
+    })
+
+    /**
+     * cobtextBridge for niveaus
+     */
+    contextBridge.exposeInMainWorld('niveaus', {
+      getNiveau: () => getNiveau(),
+      getSingleNiveau: (credential) => ipcRenderer.invoke('singleNiveau', credential),
+      insertNiveau: (credentials) => ipcRenderer.invoke('insertNiveau', credentials),
+      updateSingleNiveau: (credentials) => ipcRenderer.invoke('updateSingleNiveau', credentials),
+      importNiveau: (credentials) => ipcRenderer.invoke('importNiveau', credentials),
+      deleteNiveaus: (credentials) => ipcRenderer.invoke('deleteNiveaus', credentials)
+    })
+
+    /**
+     * contextBridge for notes
+     */
+    contextBridge.exposeInMainWorld('notes', {
+      getNotes: (credentials) => ipcRenderer.invoke('getSingleNote', credentials),
+      insertNote: (credentials) => ipcRenderer.invoke('insertNote', credentials),
+      updateNote: (credentials) => ipcRenderer.invoke('updatetNote', credentials),
+      getMoyenne: (credentials) => ipcRenderer.invoke('getMoyene', credentials),
+      noteMatiere: (credentials) => ipcRenderer.invoke('noteMatiere', credentials),
+      noteRelerer: (credentials) => ipcRenderer.invoke('noteRelerer', credentials),
+      getMoyenneVerify: () => verifyEtudiantIfHeHasNotes(),
+      getblockNote: () => blockShowMoyene()
+    })
+
+    /**
+     * contextbridge for note repechage
+     */
+    contextBridge.exposeInMainWorld('noteRepech', {
+      getNotesRepech: (credentials) => ipcRenderer.invoke('getNotesRepech', credentials),
+      updateNoteRepech: (credentials) => ipcRenderer.invoke('updatetNoteRepech', credentials),
+      getMoyenneRepech: (credentials) => ipcRenderer.invoke('getMoyenneRepech', credentials)
+    })
+
+    /**
+     * contextBridge for matieres
+     */
+    contextBridge.exposeInMainWorld('matieres', {
+      getMatiere: () => getMatiere(),
+      createMatiere: (credentials) => ipcRenderer.invoke('createMatiere', credentials),
+      getMatiereByID: (credentials) => ipcRenderer.invoke('getMatiereByID', credentials),
+      updateMatiere: (credentials) => ipcRenderer.invoke('updateMatiere', credentials),
+      importExcel: (credentials) => ipcRenderer.invoke('importExcelMatiere', credentials),
+      displayMatiereFromForm: (credentials) =>
+        ipcRenderer.invoke('displayMatiereFromForm', credentials),
+      deleteMatiere: (credentials) => ipcRenderer.invoke('deleteMatiere', credentials),
+      asign: (credentials) => ipcRenderer.invoke('asign', credentials),
+      getAsign: (credentials) => ipcRenderer.invoke('getAsign', credentials),
+      asignSemestre: (credentials) => ipcRenderer.invoke('asignSemestre', credentials),
+      getSemestreMatiere: (credentials) => ipcRenderer.invoke('getSemestreMatiere', credentials),
+      getSemestre: () => getSemestre(),
+      getNessesary: () => getNessesarytable(),
+      getENseignant: () => getEnseignants(),
+      insertUpdateMentionSemestre: (credentials) =>
+        ipcRenderer.invoke('insertUpdateMentionSemestre', credentials),
+      updateNessesary: (credentials) => ipcRenderer.invoke('updateNessesary', credentials),
+      insertProf: (credentials) => ipcRenderer.invoke('insertProf', credentials),
+      getSingleProf: (credentials) => ipcRenderer.invoke('getSingleProf', credentials),
+      updateProf: (credentials) => ipcRenderer.invoke('updateProf', credentials)
+    })
+
+    /**
+     * contextBridge for note systeme
+     */
+    contextBridge.exposeInMainWorld('notesysteme', {
+      getSyteme: () => getSysteme(),
+      updateNoteSysteme: (credentials) => ipcRenderer.invoke('updateNoteSysteme', credentials),
+      insertParcours: (credentials) => ipcRenderer.invoke('insertParcours', credentials),
+      getSingleParcours: (credentials) => ipcRenderer.invoke('getSingleParcours', credentials),
+      deleteParcours: (credentials) => ipcRenderer.invoke('deleteParcours', credentials),
+      updateParcours: (credentials) => ipcRenderer.invoke('updateParcours', credentials),
+      parcourMatiere: (credentials) => ipcRenderer.invoke('parcourMatiere', credentials),
+      getParcours: () => getParcours(),
+      extractFiches: (credentials) => ipcRenderer.invoke('extractFiches', credentials),
+      getParcourMatiere: (credentials) => ipcRenderer.invoke('getParcourMatiere', credentials),
+      createIPConfig: (credentials) => ipcRenderer.invoke('createIPConfig', credentials),
+      getIPConfig: () => getIPConfig(),
+      updateIPConfig: (credentials) => ipcRenderer.invoke('updateIPConfig', credentials)
+    })
+
+    /**
+     * contextbridge for status
+     */
+    contextBridge.exposeInMainWorld('statuss', {
+      getStatus: () => getStatus()
+    })
+
+    /**
+     * contextbridge for annee scolaire
+     */
+    contextBridge.exposeInMainWorld('anneescolaire', {
+      getAnneeScolaire: () => getAnneeScolaire(),
+      getInterval: () => getInterval(),
+      createAnneeScolaire: (credentials) => ipcRenderer.invoke('createAnneeScolaire', credentials),
+      deleteAnneeScolaire: (credentials) => ipcRenderer.invoke('deleteAnneeScolaire', credentials),
+      getSingleAnneeScolaire: (credentials) =>
+        ipcRenderer.invoke('getSingleAnneeScolaire', credentials),
+      updateAnneeScolaire: (credentials) => ipcRenderer.invoke('updateAnneeScolaire', credentials),
+      setCurrent: (credentials) => ipcRenderer.invoke('setCurrent', credentials)
+    })
+
+    /**
+     * contextbridge for mention
+     */
+    contextBridge.exposeInMainWorld('mention', {
+      createMention: (credentials) => ipcRenderer.invoke('createMention', credentials),
+      getMention: () => getMentions(),
+      getSingleMention: (credentials) => ipcRenderer.invoke('getSingleMention', credentials),
+      updateMention: (credentials) => ipcRenderer.invoke('updateMention', credentials),
+      deleteMention: (credentials) => ipcRenderer.invoke('deleteMention', credentials)
+    })
+  } catch (error) {
+    console.error(error)
+  }
+} else {
+  window.electron = electronAPI
+  window.api = api
+}

src/preload/index.js

@@ -5,10 +5,6 @@ const { getNiveau } = require('../../database/Models/Niveau')
 const { getAllUsers } = require('../../database/Models/Users')
 const { getAllEtudiants, getDataToDashboard } = require('../../database/Models/Etudiants')
 const { verifyEtudiantIfHeHasNotes, blockShowMoyene } = require('../../database/Models/Notes')
-
-const { synchronizeData } = require('../../database/api/SyncronisationDataUsers')
-const { synchronizeDataEtudiants } = require('../../database/api/SyncronisationDataEtudiants')
-const { synchronizeDataNotes } = require('../../database/api/CheckUpdateNote')
 const { getMatiere, getSemestre, getEnseignants } = require('../../database/Models/Matieres')
 const { getSysteme } = require('../../database/Models/NoteSysrem')
 const { getStatus } = require('../../database/Models/Status')