database/Models/AnneeScolaire.js

@@ -1,4 +1,4 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 
 /**
  * function to create annee scolaire
@@ -8,17 +8,14 @@ const { pool } = require('../database')
  * @returns promise
  */
 async function createAnneeScolaire(code, debut, fin) {
-  const sql = 'INSERT INTO anneescolaire (code, debut, fin) VALUES (?, ?, ?)'
+  const query = database.prepare('INSERT INTO anneescolaire (code, debut, fin) VALUES (?, ?, ?)')
 
   try {
-    let [result] = await pool.query(sql, [code, debut, fin])
+    let response = await query.run(code, debut, fin)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
@@ -27,101 +24,81 @@ async function createAnneeScolaire(code, debut, fin) {
  * @returns promise
  */
 async function getAnneeScolaire() {
-  const sql = 'SELECT * FROM anneescolaire ORDER BY code DESC'
+  const query = database.prepare('SELECT * FROM anneescolaire ORDER BY code DESC')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function getInterval() {
-  const sql = 'SELECT debut, fin FROM anneescolaire ORDER BY id DESC'
+  const query = database.prepare('SELECT debut, fin FROM anneescolaire ORDER BY id DESC')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function getSingleAnneScolaire(id) {
-  const sql = 'SELECT * FROM anneescolaire WHERE id = ?'
+  const query = database.prepare('SELECT * FROM anneescolaire WHERE id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = await query.get(id)
 
-    return rows[0]
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function deleteAnneeScolaire(id) {
-  const sql = 'DELETE FROM anneescolaire WHERE id = ?'
+  const query = database.prepare('DELETE FROM anneescolaire WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [id])
+    let response = query.run(id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function updateAnneeScolaire(id, code, debut, fin) {
-  const sql = 'UPDATE anneescolaire SET code = ?, debut = ?, fin = ? WHERE id = ?'
+  const query = database.prepare(
+    'UPDATE anneescolaire SET code = ?, debut = ?, fin = ? WHERE id = ?'
+  )
 
   try {
-    let [result] = await pool.query(sql, [code, debut, fin, id])
+    let response = query.run(code, debut, fin, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé ou aucune modification effectuée.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire mis à jour avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function setCurrent(id) {
-  const sql = 'UPDATE anneescolaire SET is_current = 0 WHERE id > 0 AND is_current = 1'
+  const query = database.prepare(
-  const sql2 = 'UPDATE anneescolaire SET is_current = 1 WHERE id = ?'
+    'UPDATE anneescolaire SET is_current = 0 WHERE id > 0 AND is_current = 1'
-
+  )
-  pool.query(sql)
+  const query2 = database.prepare('UPDATE anneescolaire SET is_current = 1 WHERE id = ?')
 
+  let clear = query.run()
+  console.log(clear)
   try {
-    const [result] = pool.query(sql2, [id])
+    let response = query2.run(id)
-    console.log(result)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 

database/Models/Etudiants.backup.js

@@ -1,305 +0,0 @@
-const { database } = require('../database.backup')
-
-/**
- * function to insert etudiant into databases
- */
-async function insertEtudiant(
-  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
-) {
-  const query = database.prepare(
-    'INSERT INTO etudiants (nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, status, mention_id, num_inscription, sexe, cin, date_delivrance, nationalite, annee_bacc, serie, boursier, domaine, contact, parcours) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
-  )
-
-  try {
-    let response = await query.run(
-      nom,
-      prenom,
-      photos,
-      date_de_naissances,
-      niveau,
-      annee_scolaire,
-      status,
-      mention_id,
-      num_inscription,
-      sexe,
-      cin,
-      date_delivrence,
-      nationaliter,
-      annee_bacc,
-      serie,
-      boursier,
-      domaine,
-      contact,
-      parcours
-    )
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to get all etudiants
- *
- * @returns JSON
- */
-async function getAllEtudiants() {
-  const query = database.prepare('SELECT * FROM etudiants ORDER BY annee_scolaire DESC')
-  try {
-    let response = await query.all()
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to return a single etudiant
- * and display it on the screen
- *
- * @param {int} id
- * @returns Promise
- */
-async function getSingleEtudiant(id) {
-  const query = database.prepare('SELECT * FROM etudiants WHERE id = ?')
-
-  try {
-    const etudiants = await query.get(id)
-
-    if (etudiants) {
-      return etudiants
-    } else {
-      return { message: 'etudiants pas trouver' }
-    }
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to get all etudiants M2
- *
- * @returns JSON
- */
-async function FilterDataByNiveau(niveau) {
-  const query = database.prepare(
-    'SELECT * FROM etudiants WHERE niveau = ? ORDER BY annee_scolaire DESC'
-  )
-  try {
-    let response = await query.all(niveau)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to update etudiants
- *
- * @param {*} nom
- * @param {*} prenom
- * @param {*} photos
- * @param {*} date_de_naissances
- * @param {*} niveau
- * @param {*} annee_scolaire
- * @param {*} status
- * @param {*} num_inscription
- * @param {*} id
- * @returns promise
- */
-async function updateEtudiant(
-  nom,
-  prenom,
-  photos,
-  date_de_naissances,
-  niveau,
-  annee_scolaire,
-  status,
-  mention_id,
-  num_inscription,
-  id,
-  sexe,
-  nationalite,
-  cin,
-  date_delivrence,
-  annee_bacc,
-  serie,
-  boursier,
-  domaine,
-  contact,
-  parcours
-) {
-  const query = database.prepare(
-    'UPDATE etudiants SET nom = ?, prenom = ?, photos = ?, date_de_naissances = ?, niveau = ?, annee_scolaire = ?, status = ?, mention_id = ?, num_inscription = ?, sexe = ?, cin = ?, date_delivrance = ?, nationalite = ?, annee_bacc = ?, serie = ?, boursier = ?, domaine = ?, contact = ?, parcours = ? WHERE id = ?'
-  )
-
-  try {
-    let response = await query.run(
-      nom,
-      prenom,
-      photos,
-      date_de_naissances,
-      niveau,
-      annee_scolaire,
-      status,
-      mention_id,
-      num_inscription,
-      sexe,
-      cin,
-      date_delivrence,
-      nationalite,
-      annee_bacc,
-      serie,
-      boursier,
-      domaine,
-      contact,
-      parcours,
-      id
-    )
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to return the needed data in dashboard
- *
- * @returns promise
- */
-async function getDataToDashboard() {
-  const query = database.prepare('SELECT * FROM niveaus')
-  const query2 = database.prepare('SELECT * FROM etudiants')
-  const query3 = database.prepare('SELECT DISTINCT annee_scolaire FROM etudiants') // get all année scolaire sans doublan
-
-  try {
-    let niveau = query.all()
-    let etudiants = query2.all()
-    let anne_scolaire = query3.all()
-
-    return { niveau, etudiants, anne_scolaire }
-  } catch (error) {
-    return error
-  }
-}
-
-async function changePDP(photos, id) {
-  const query = database.prepare('UPDATE etudiants SET photos = ? WHERE id = ?')
-
-  try {
-    let response = await query.run(photos, id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function updateParcours(parcours, id) {
-  const query = database.prepare('UPDATE etudiants SET parcours = ? WHERE id = ?')
-
-  try {
-    let response = await query.run(parcours, id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function createTranche(etudiant_id, tranchename, montant) {
-  const query = database.prepare(
-    'INSERT INTO trancheecolage (etudiant_id, tranchename, montant) VALUES (?, ?, ?)'
-  )
-
-  try {
-    let response = query.run(etudiant_id, tranchename, montant)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getTranche(id) {
-  const query = database.prepare('SELECT * FROM trancheecolage WHERE etudiant_id = ?')
-
-  try {
-    let response = query.all(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function updateTranche(id, tranchename, montant) {
-  const query = database.prepare(
-    'UPDATE trancheecolage SET tranchename = ?, montant = ? WHERE id = ?'
-  )
-
-  try {
-    let response = query.run(tranchename, montant, id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function deleteTranche(id) {
-  const query = database.prepare('DELETE FROM trancheecolage WHERE id = ?')
-
-  try {
-    let response = query.run(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getSingleTranche(id) {
-  try {
-    return await database.prepare('SELECT * FROM trancheecolage WHERE id = ?').get(id)
-  } catch (error) {
-    return error
-  }
-}
-
-module.exports = {
-  insertEtudiant,
-  getAllEtudiants,
-  FilterDataByNiveau,
-  getSingleEtudiant,
-  updateEtudiant,
-  getDataToDashboard,
-  changePDP,
-  updateParcours,
-  createTranche,
-  getTranche,
-  updateTranche,
-  deleteTranche,
-  getSingleTranche
-}

database/Models/Etudiants.js

@@ -1,4 +1,4 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 
 /**
  * function to insert etudiant into databases
@@ -24,11 +24,12 @@ async function insertEtudiant(
   contact,
   parcours
 ) {
-  const sql =
+  const query = database.prepare(
     'INSERT INTO etudiants (nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, status, mention_id, num_inscription, sexe, cin, date_delivrance, nationalite, annee_bacc, serie, boursier, domaine, contact, parcours) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
+  )
 
   try {
-    let [result] = await pool.query(sql, [
+    let response = await query.run(
       nom,
       prenom,
       photos,
@@ -48,12 +49,8 @@ async function insertEtudiant(
       domaine,
       contact,
       parcours
-    ])
+    )
-
+    return response
-    return {
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
     return error
   }
@@ -65,11 +62,11 @@ async function insertEtudiant(
  * @returns JSON
  */
 async function getAllEtudiants() {
-  const sql = 'SELECT * FROM etudiants ORDER BY annee_scolaire DESC'
+  const query = database.prepare('SELECT * FROM etudiants ORDER BY annee_scolaire DESC')
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
@@ -83,12 +80,16 @@ async function getAllEtudiants() {
  * @returns Promise
  */
 async function getSingleEtudiant(id) {
-  const sql = 'SELECT * FROM etudiants WHERE id = ?'
+  const query = database.prepare('SELECT * FROM etudiants WHERE id = ?')
 
   try {
-    const [rows] = await pool.query(sql, [id])
+    const etudiants = await query.get(id)
 
-    return rows[0]
+    if (etudiants) {
+      return etudiants
+    } else {
+      return { message: 'etudiants pas trouver' }
+    }
   } catch (error) {
     return error
   }
@@ -100,11 +101,13 @@ async function getSingleEtudiant(id) {
  * @returns JSON
  */
 async function FilterDataByNiveau(niveau) {
-  const sql = 'SELECT * FROM etudiants WHERE niveau = ? ORDER BY annee_scolaire DESC'
+  const query = database.prepare(
+    'SELECT * FROM etudiants WHERE niveau = ? ORDER BY annee_scolaire DESC'
+  )
   try {
-    let [rows] = await pool.query(sql, [niveau])
+    let response = await query.all(niveau)
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
@@ -146,11 +149,12 @@ async function updateEtudiant(
   contact,
   parcours
 ) {
-  const sql =
+  const query = database.prepare(
     'UPDATE etudiants SET nom = ?, prenom = ?, photos = ?, date_de_naissances = ?, niveau = ?, annee_scolaire = ?, status = ?, mention_id = ?, num_inscription = ?, sexe = ?, cin = ?, date_delivrance = ?, nationalite = ?, annee_bacc = ?, serie = ?, boursier = ?, domaine = ?, contact = ?, parcours = ? WHERE id = ?'
+  )
 
   try {
-    let [result] = await pool.query(sql, [
+    let response = await query.run(
       nom,
       prenom,
       photos,
@@ -171,19 +175,9 @@ async function updateEtudiant(
       contact,
       parcours,
       id
-    ])
+    )
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
     return error
   }
@@ -195,17 +189,14 @@ async function updateEtudiant(
  * @returns promise
  */
 async function getDataToDashboard() {
-  const query = 'SELECT * FROM niveaus'
+  const query = database.prepare('SELECT * FROM niveaus')
-  const query2 = 'SELECT * FROM etudiants'
+  const query2 = database.prepare('SELECT * FROM etudiants')
-  const query3 = 'SELECT DISTINCT annee_scolaire FROM etudiants' // get all année scolaire sans doublan
+  const query3 = database.prepare('SELECT DISTINCT annee_scolaire FROM etudiants') // get all année scolaire sans doublan
 
   try {
-    let [rows] = await pool.query(query)
+    let niveau = query.all()
-    let niveau = rows
+    let etudiants = query2.all()
-    ;[rows] = await pool.query(query2)
+    let anne_scolaire = query3.all()
-    let etudiants = rows
-    ;[rows] = await pool.query(query3)
-    let anne_scolaire = rows
 
     return { niveau, etudiants, anne_scolaire }
   } catch (error) {
@@ -214,59 +205,38 @@ async function getDataToDashboard() {
 }
 
 async function changePDP(photos, id) {
-  const sql = 'UPDATE etudiants SET photos = ? WHERE id = ?'
+  const query = database.prepare('UPDATE etudiants SET photos = ? WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [photos, id])
+    let response = await query.run(photos, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
     return error
   }
 }
 
 async function updateParcours(parcours, id) {
-  const sql = 'UPDATE etudiants SET parcours = ? WHERE id = ?'
+  const query = database.prepare('UPDATE etudiants SET parcours = ? WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [parcours, id])
+    let response = await query.run(parcours, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
     return error
   }
 }
 
 async function createTranche(etudiant_id, tranchename, montant) {
-  const sql = 'INSERT INTO trancheecolage (etudiant_id, tranchename, montant) VALUES (?, ?, ?)'
+  const query = database.prepare(
+    'INSERT INTO trancheecolage (etudiant_id, tranchename, montant) VALUES (?, ?, ?)'
+  )
 
   try {
-    let [result] = pool.query(sql, [etudiant_id, tranchename, montant])
+    let response = query.run(etudiant_id, tranchename, montant)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
     return error
   }

database/Models/IpConfig.js

@@ -1,4 +1,4 @@
-const { database } = require('../database.backup');
+const { database } = require('../database');
 
 const createConfigIp = (ipname) => {
   const query = database.prepare('INSERT INTO ipconfig (ipname) VALUES (?)');

database/Models/Matieres.backup.js

@@ -1,354 +0,0 @@
-const { database } = require('../database.backup')
-const { matiereSysteme } = require('../function/System')
-const { convertArrayAndString } = require('../function/StringArrayConvertion')
-
-/**
- * function uset to create matiere
- * @param {*} nom
- * @returns Promise
- */
-async function createMatiere(nom, credit, uniter, ue) {
-  const query = database.prepare(
-    'INSERT INTO matieres (nom, unite_enseignement, credit, heure, ue) VALUES (?, ?, ?, ?, ?)'
-  )
-
-  const uniterHeure = database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
-  const heure = credit * uniterHeure.uniter_heure
-
-  try {
-    response = await query.run(nom, uniter, credit, heure, ue)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function to get all matieres
- * @returns Promise
- */
-async function getMatiere() {
-  const query = database.prepare('SELECT * FROM matieres ORDER BY id DESC')
-
-  try {
-    let response = await query.all()
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function displayMatiereFromForm(niveau, mention_id, parcours) {
-  // Fetch the semestre array
-  let semestre = await matiereSysteme(niveau) // Ensure this returns an array with at least 2 items
-
-  if (niveau !== 'L1') {
-    if (semestre.length < 2) {
-      console.error('Error: Semestre array does not contain enough elements.')
-      return
-    }
-
-    // Prepare the query
-    let matiereQuery = database.prepare(`
-      SELECT DISTINCT m.*
-      FROM matieres m
-      JOIN matiere_semestre ms ON m.id = ms.matiere_id
-      JOIN semestres s ON ms.semestre_id = s.id
-      JOIN parcoursmatiere pm ON m.id = pm.matiere_id
-      JOIN parcours p ON pm.parcour_id = p.id
-      WHERE (s.nom LIKE ? OR s.nom LIKE ?)
-        AND ms.mention_id = ?
-        AND p.nom = ?
-    `)
-
-    try {
-      // Execute the query with parameters
-      let response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id, parcours)
-
-      console.log(response)
-      // Log the response
-      return response
-    } catch (error) {
-      return error
-    }
-  } else {
-    if (semestre.length < 2) {
-      console.error('Error: Semestre array does not contain enough elements.')
-      return
-    }
-
-    // Prepare the query
-    let matiereQuery = database.prepare(`
-      SELECT DISTINCT m.*
-      FROM matieres m
-      JOIN matiere_semestre ms ON m.id = ms.matiere_id
-      JOIN semestres s ON ms.semestre_id = s.id
-      WHERE (s.nom LIKE ? OR s.nom LIKE ?)
-        AND ms.mention_id = ?
-    `)
-
-    try {
-      // Execute the query with parameters
-      let response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id)
-      console.log(response)
-      // Log the response
-      return response
-    } catch (error) {
-      return error
-    }
-  }
-}
-
-/**
- * function to get single matiere
- * @param {*} id
- * @returns promise
- */
-async function getSingleMatiere(id) {
-  const query = await database.prepare('SELECT * FROM matieres WHERE id = ?')
-
-  try {
-    let response = query.get(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-/**
- * function used when updating matiere
- * @param {*} nom
- * @param {*} id
- * @returns promise
- */
-async function updateMatiere(nom, id, credit, uniter, ue) {
-  const query = database.prepare(
-    'UPDATE matieres SET nom = ?, credit = ?, unite_enseignement = ?, heure = ?, ue = ? WHERE id = ?'
-  )
-
-  const uniterHeure = await database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
-  const heure = credit * uniterHeure.uniter_heure
-
-  try {
-    response = await query.run(nom, credit, uniter, heure, ue, id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function deleteMatiere(id) {
-  const query = database.prepare('DELETE FROM matieres WHERE id = ?')
-
-  try {
-    let response = query.run(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function asygnationToMention(formData, id) {
-  const clearQuery = database.prepare('DELETE FROM matiere_mention WHERE matiere_id = ?')
-  const query = database.prepare(
-    'INSERT INTO matiere_mention (matiere_id, mention_id) VALUES (?,?)'
-  )
-  const selectedKeys = Object.keys(formData).filter((key) => formData[key])
-  const placeholders = selectedKeys.map(() => '?').join(',')
-  // Prepare the query with placeholders
-  const clearSemestreMentionQuery = database.prepare(
-    `DELETE FROM matiere_semestre WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
-  )
-
-  const clearNoreQuery = database.prepare(
-    `DELETE FROM notes WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
-  )
-
-  try {
-    let response
-    await clearQuery.run(id)
-    await clearNoreQuery.run(id, ...selectedKeys)
-    clearSemestreMentionQuery.run(id, ...selectedKeys)
-    // use transaction for speed execution
-    database.transaction(() => {
-      for (let index = 0; index < selectedKeys.length; index++) {
-        response = query.run(id, selectedKeys[index])
-      }
-    })()
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getMentionMatiere(id) {
-  const query = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
-
-  try {
-    let response = await query.all(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getMentionMatiereChecked(matiere_id) {
-  const getMentionMatiere = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
-  let MentionArray = await getMentionMatiere.all(matiere_id)
-  let arrayID = []
-
-  for (let index = 0; index < MentionArray.length; index++) {
-    arrayID.push(MentionArray[index].mention_id)
-  }
-
-  const mentionQuery = database.prepare(
-    `SELECT * FROM mentions WHERE id IN (${arrayID.map(() => '?').join(', ')})`
-  )
-
-  try {
-    const results = await mentionQuery.all(...arrayID)
-
-    return results
-  } catch (error) {
-    return error
-  }
-}
-
-async function getSemestreMatiere(id) {
-  const query = database.prepare('SELECT * FROM matiere_semestre WHERE matiere_id = ?')
-
-  try {
-    let response = await query.all(id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getSemestre() {
-  const query = database.prepare('SELECT * FROM semestres')
-
-  try {
-    let response = await query.all()
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function insertUpdateMentionSemestre(matiere_id, formData) {
-  const clearQuery = database.prepare('DELETE FROM matiere_semestre WHERE matiere_id = ?')
-  clearQuery.run(matiere_id)
-
-  const query = database.prepare(
-    'INSERT INTO matiere_semestre (matiere_id, semestre_id, mention_id) VALUES (?, ?, ?)'
-  )
-  let response
-  database.transaction(() => {
-    for (const key in formData) {
-      if (formData.hasOwnProperty(key)) {
-        for (let jindex = 0; jindex < formData[key].length; jindex++) {
-          response = query.run(matiere_id, formData[key][jindex], key)
-        }
-      }
-    }
-  })()
-  return response
-}
-
-async function getEnseignants() {
-  const getIdQuery = database.prepare(
-    'SELECT id FROM matiereEnseignants GROUP BY matiere_id ORDER BY MAX(date) DESC'
-  )
-
-  const query = database.prepare(
-    'SELECT * FROM matiereEnseignants WHERE id IN (' +
-      new Array(getIdQuery.all().length).fill('?').join(',') +
-      ')'
-  )
-
-  try {
-    // Get the latest `id` for each `matiere_id`
-    const latestIds = getIdQuery.all().map((row) => row.id)
-
-    // If no ids exist, return an empty array
-    if (latestIds.length === 0) {
-      return []
-    }
-
-    // Fetch the full details using the filtered IDs
-    let response = query.all(...latestIds)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function insertNewProf(matiere_id, nom, prenom, contact, date) {
-  const query = database.prepare(
-    'INSERT INTO matiereEnseignants (matiere_id, nom_enseignant, prenom_enseignant, contact, date) VALUES (?, ?, ?, ?, ?)'
-  )
-
-  try {
-    let response = query.run(matiere_id, nom, prenom, contact, date)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-async function getSIngleProf(id) {
-  try {
-    const prof = await database
-      .prepare('SELECT * FROM matiereEnseignants WHERE matiere_id = ?')
-      .get(id)
-
-    return prof
-  } catch (error) {
-    return error
-  }
-}
-
-async function updateProf(matiere_id, nom, prenom, contact, date) {
-  const query = database.prepare(
-    'UPDATE matiereEnseignants SET nom_enseignant = ?, prenom_enseignant = ?, contact = ?, date = ? WHERE matiere_id = ?'
-  )
-
-  try {
-    let response = query.run(nom, prenom, contact, date, matiere_id)
-
-    return response
-  } catch (error) {
-    return error
-  }
-}
-
-module.exports = {
-  createMatiere,
-  getSIngleProf,
-  getMatiere,
-  getSingleMatiere,
-  updateMatiere,
-  displayMatiereFromForm,
-  deleteMatiere,
-  asygnationToMention,
-  getMentionMatiere,
-  getMentionMatiereChecked,
-  getSemestreMatiere,
-  getSemestre,
-  insertUpdateMentionSemestre,
-  getEnseignants,
-  insertNewProf,
-  updateProf
-}

database/Models/Matieres.js

@@ -1,5 +1,6 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 const { matiereSysteme } = require('../function/System')
+const { convertArrayAndString } = require('../function/StringArrayConvertion')
 
 /**
  * function uset to create matiere
@@ -7,22 +8,19 @@ const { matiereSysteme } = require('../function/System')
  * @returns Promise
  */
 async function createMatiere(nom, credit, uniter, ue) {
-  const sql =
+  const query = database.prepare(
     'INSERT INTO matieres (nom, unite_enseignement, credit, heure, ue) VALUES (?, ?, ?, ?, ?)'
+  )
+
+  const uniterHeure = database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
+  const heure = credit * uniterHeure.uniter_heure
 
-  const uniterHeure = 'SELECT uniter_heure FROM nessesaryTable'
-  let [rows] = await pool.query(uniterHeure)
-  const uniterHeureValue = rows[0].uniter_heure
-  const heure = credit * uniterHeureValue
   try {
-    const [result] = await pool.query(sql, [nom, uniter, credit, heure, ue])
+    response = await query.run(nom, uniter, credit, heure, ue)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
@@ -31,14 +29,14 @@ async function createMatiere(nom, credit, uniter, ue) {
  * @returns Promise
  */
 async function getMatiere() {
-  const sql = 'SELECT * FROM matieres ORDER BY id DESC'
+  const query = database.prepare('SELECT * FROM matieres ORDER BY id DESC')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
@@ -53,7 +51,7 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
     }
 
     // Prepare the query
-    let matiereQuery = `
+    let matiereQuery = database.prepare(`
       SELECT DISTINCT m.*
       FROM matieres m
       JOIN matiere_semestre ms ON m.id = ms.matiere_id
@@ -63,21 +61,17 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
       WHERE (s.nom LIKE ? OR s.nom LIKE ?)
         AND ms.mention_id = ?
         AND p.nom = ?
-    `
+    `)
 
     try {
       // Execute the query with parameters
-      let [rows] = await pool.query(matiereQuery, [
+      let response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id, parcours)
-        `%${semestre[0]}%`,
-        `%${semestre[1]}%`,
-        mention_id,
-        parcours
-      ])
 
+      console.log(response)
       // Log the response
-      return rows
+      return response
     } catch (error) {
-      return { success: false, error: 'Erreur veullez réeseyer' + error }
+      return error
     }
   } else {
     if (semestre.length < 2) {
@@ -86,27 +80,23 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
     }
 
     // Prepare the query
-    let matiereQuery = `
+    let matiereQuery = database.prepare(`
       SELECT DISTINCT m.*
       FROM matieres m
       JOIN matiere_semestre ms ON m.id = ms.matiere_id
       JOIN semestres s ON ms.semestre_id = s.id
       WHERE (s.nom LIKE ? OR s.nom LIKE ?)
         AND ms.mention_id = ?
-    `
+    `)
 
     try {
       // Execute the query with parameters
-      let [rows] = await pool.query(matiereQuery, [
+      let response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id)
-        `%${semestre[0]}%`,
+      console.log(response)
-        `%${semestre[1]}%`,
-        mention_id
-      ])
-
       // Log the response
-      return rows
+      return response
     } catch (error) {
-      return { success: false, error: 'Erreur veullez réeseyer' + error }
+      return error
     }
   }
 }
@@ -117,14 +107,14 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
  * @returns promise
  */
 async function getSingleMatiere(id) {
-  const sql = 'SELECT * FROM matieres WHERE id = ?'
+  const query = await database.prepare('SELECT * FROM matieres WHERE id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = query.get(id)
 
-    return rows[0]
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
@@ -135,325 +125,211 @@ async function getSingleMatiere(id) {
  * @returns promise
  */
 async function updateMatiere(nom, id, credit, uniter, ue) {
-  const sql =
+  const query = database.prepare(
     'UPDATE matieres SET nom = ?, credit = ?, unite_enseignement = ?, heure = ?, ue = ? WHERE id = ?'
+  )
 
-  const uniterHeure = 'SELECT uniter_heure FROM nessesaryTable'
+  const uniterHeure = await database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
-  let [rows] = await pool.query(uniterHeure)
+  const heure = credit * uniterHeure.uniter_heure
-  const uniterHeureValue = rows[0].uniter_heure
-  const heure = credit * uniterHeureValue
 
   try {
-    let [result] = await pool.query(sql, [nom, credit, uniter, heure, ue, id])
+    response = await query.run(nom, credit, uniter, heure, ue, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé ou aucune modification effectuée.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire mis à jour avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
 async function deleteMatiere(id) {
-  const sql = 'DELETE FROM matieres WHERE id = ?'
+  const query = database.prepare('DELETE FROM matieres WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [id])
+    let response = query.run(id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
-/**
- * Assign mentions to a matiere
- * @param {Object} formData - keys = mention_ids, values = true/false
- * @param {number} id - matiere_id
- */
 async function asygnationToMention(formData, id) {
+  const clearQuery = database.prepare('DELETE FROM matiere_mention WHERE matiere_id = ?')
+  const query = database.prepare(
+    'INSERT INTO matiere_mention (matiere_id, mention_id) VALUES (?,?)'
+  )
   const selectedKeys = Object.keys(formData).filter((key) => formData[key])
-
-  if (selectedKeys.length === 0) {
-    return { success: false, error: 'No mentions selected.' }
-  }
-
-  // build placeholders like (?, ?, ?)
   const placeholders = selectedKeys.map(() => '?').join(',')
+  // Prepare the query with placeholders
+  const clearSemestreMentionQuery = database.prepare(
+    `DELETE FROM matiere_semestre WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
+  )
 
-  const deleteMentionSql = `
+  const clearNoreQuery = database.prepare(
-    DELETE FROM matiere_mention
+    `DELETE FROM notes WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
-    WHERE matiere_id = ?
+  )
-  `
-
-  const deleteSemestreMentionSql = `
-    DELETE FROM matiere_semestre
-    WHERE matiere_id = ?
-    AND mention_id NOT IN (${placeholders})
-  `
-
-  const deleteNotesSql = `
-    DELETE FROM notes
-    WHERE matiere_id = ?
-    AND mention_id NOT IN (${placeholders})
-  `
-
-  const insertMentionSql = `
-    INSERT INTO matiere_mention (matiere_id, mention_id)
-    VALUES (?, ?)
-  `
 
   try {
-    const connection = await pool.getConnection()
+    let response
-    try {
+    await clearQuery.run(id)
-      await connection.beginTransaction()
+    await clearNoreQuery.run(id, ...selectedKeys)
-
+    clearSemestreMentionQuery.run(id, ...selectedKeys)
-      // delete all from matiere_mention for this matiere
+    // use transaction for speed execution
-      await connection.query(deleteMentionSql, [id])
+    database.transaction(() => {
-
+      for (let index = 0; index < selectedKeys.length; index++) {
-      // delete from matiere_semestre not in selected mentions
+        response = query.run(id, selectedKeys[index])
-      await connection.query(deleteSemestreMentionSql, [id, ...selectedKeys])
-
-      // delete from notes not in selected mentions
-      await connection.query(deleteNotesSql, [id, ...selectedKeys])
-
-      // re-insert new mentions
-      for (const mentionId of selectedKeys) {
-        await connection.query(insertMentionSql, [id, mentionId])
       }
+    })()
 
-      await connection.commit()
+    return response
-
+  } catch (error) {
-      return { success: true }
+    return error
-    } catch (error) {
-      await connection.rollback()
-      console.error(error)
-      return { success: false, error: error.message }
-    } finally {
-      connection.release()
-    }
-  } catch (connErr) {
-    console.error(connErr)
-    return { success: false, error: 'Database connection error.' }
   }
 }
 
 async function getMentionMatiere(id) {
-  const sql = 'SELECT * FROM matiere_mention WHERE matiere_id = ?'
+  const query = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = await query.all(id)
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
 }
 
 async function getMentionMatiereChecked(matiere_id) {
-  const getMentionMatiere = 'SELECT * FROM matiere_mention WHERE matiere_id = ?'
+  const getMentionMatiere = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
-  let [rows] = await pool.query(getMentionMatiere, [matiere_id])
+  let MentionArray = await getMentionMatiere.all(matiere_id)
-  let MentionArray = rows
   let arrayID = []
 
   for (let index = 0; index < MentionArray.length; index++) {
     arrayID.push(MentionArray[index].mention_id)
   }
 
-  const mentionQuery = `SELECT * FROM mentions WHERE id IN (${arrayID.map(() => '?').join(', ')})`
+  const mentionQuery = database.prepare(
+    `SELECT * FROM mentions WHERE id IN (${arrayID.map(() => '?').join(', ')})`
+  )
 
   try {
-    let [rows] = await pool.query(mentionQuery, [...arrayID])
+    const results = await mentionQuery.all(...arrayID)
 
-    return rows
+    return results
   } catch (error) {
     return error
   }
 }
 
 async function getSemestreMatiere(id) {
-  const sql = 'SELECT * FROM matiere_semestre WHERE matiere_id = ?'
+  const query = database.prepare('SELECT * FROM matiere_semestre WHERE matiere_id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = await query.all(id)
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
 }
 
 async function getSemestre() {
-  const sql = 'SELECT * FROM semestres'
+  const query = database.prepare('SELECT * FROM semestres')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
 }
 
 async function insertUpdateMentionSemestre(matiere_id, formData) {
-  try {
+  const clearQuery = database.prepare('DELETE FROM matiere_semestre WHERE matiere_id = ?')
-    const connection = await pool.getConnection()
+  clearQuery.run(matiere_id)
 
-    try {
+  const query = database.prepare(
-      await connection.beginTransaction()
+    'INSERT INTO matiere_semestre (matiere_id, semestre_id, mention_id) VALUES (?, ?, ?)'
-
+  )
-      // Clear all old rows
+  let response
-      const deleteSql = `
+  database.transaction(() => {
-        DELETE FROM matiere_semestre
+    for (const key in formData) {
-        WHERE matiere_id = ?
+      if (formData.hasOwnProperty(key)) {
-      `
+        for (let jindex = 0; jindex < formData[key].length; jindex++) {
-      await connection.query(deleteSql, [matiere_id])
+          response = query.run(matiere_id, formData[key][jindex], key)
-
-      // Prepare INSERT
-      const insertSql = `
-        INSERT INTO matiere_semestre (matiere_id, semestre_id, mention_id)
-        VALUES (?, ?, ?)
-      `
-
-      // Insert new rows
-      for (const mention_id of Object.keys(formData)) {
-        for (const semestre_id of formData[mention_id]) {
-          await connection.query(insertSql, [matiere_id, semestre_id, mention_id])
         }
       }
-
-      await connection.commit()
-
-      return { success: true }
-    } catch (err) {
-      await connection.rollback()
-      console.error(err)
-      return { success: false, error: err.message }
-    } finally {
-      connection.release()
     }
-  } catch (err) {
+  })()
-    console.error(err)
+  return response
-    return { success: false, error: 'Database connection failed.' }
-  }
 }
 
 async function getEnseignants() {
+  const getIdQuery = database.prepare(
+    'SELECT id FROM matiereEnseignants GROUP BY matiere_id ORDER BY MAX(date) DESC'
+  )
+
+  const query = database.prepare(
+    'SELECT * FROM matiereEnseignants WHERE id IN (' +
+      new Array(getIdQuery.all().length).fill('?').join(',') +
+      ')'
+  )
+
   try {
-    const latestIdsSql = `
+    // Get the latest `id` for each `matiere_id`
-      SELECT MAX(id) AS id
+    const latestIds = getIdQuery.all().map((row) => row.id)
-      FROM matiereEnseignants
-      GROUP BY matiere_id
-      ORDER BY MAX(date) DESC
-    `
-
-    const [rows] = await pool.query(latestIdsSql)
-
-    const latestIds = rows.map((r) => r.id)
 
+    // If no ids exist, return an empty array
     if (latestIds.length === 0) {
       return []
     }
 
-    // Build placeholders (?, ?, ?, …)
+    // Fetch the full details using the filtered IDs
-    const placeholders = latestIds.map(() => `?`).join(`,`)
+    let response = query.all(...latestIds)
-    const fetchSql = `
-      SELECT *
-      FROM matiereEnseignants
-      WHERE id IN (${placeholders})
-    `
 
-    const [enseignants] = await pool.query(fetchSql, latestIds)
+    return response
-
-    return enseignants
   } catch (error) {
-    console.error(error)
     return error
   }
 }
 
 async function insertNewProf(matiere_id, nom, prenom, contact, date) {
-  const sql = `
+  const query = database.prepare(
-    INSERT INTO matiereEnseignants
+    'INSERT INTO matiereEnseignants (matiere_id, nom_enseignant, prenom_enseignant, contact, date) VALUES (?, ?, ?, ?, ?)'
-      (matiere_id, nom_enseignant, prenom_enseignant, contact, date)
+  )
-    VALUES (?, ?, ?, ?, ?)
-  `
 
   try {
-    const [result] = await pool.query(sql, [matiere_id, nom, prenom, contact, date])
+    let response = query.run(matiere_id, nom, prenom, contact, date)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
-    console.error(error)
     return error
   }
 }
 
-async function getSIngleProf(matiere_id) {
+async function getSIngleProf(id) {
-  const sql = `
-    SELECT *
-    FROM matiereEnseignants
-    WHERE matiere_id = ?
-    ORDER BY date DESC
-    LIMIT 1
-  `
-
   try {
-    const [rows] = await pool.query(sql, [matiere_id])
+    const prof = await database
-    return rows[0] || null
+      .prepare('SELECT * FROM matiereEnseignants WHERE matiere_id = ?')
+      .get(id)
+
+    return prof
   } catch (error) {
-    console.error(error)
     return error
   }
 }
 
 async function updateProf(matiere_id, nom, prenom, contact, date) {
-  const sql = `
+  const query = database.prepare(
-    UPDATE matiereEnseignants
+    'UPDATE matiereEnseignants SET nom_enseignant = ?, prenom_enseignant = ?, contact = ?, date = ? WHERE matiere_id = ?'
-    SET nom_enseignant = ?,
+  )
-        prenom_enseignant = ?,
-        contact = ?,
-        date = ?
-    WHERE matiere_id = ?
-  `
 
   try {
-    const [result] = await pool.query(sql, [nom, prenom, contact, date, matiere_id])
+    let response = query.run(nom, prenom, contact, date, matiere_id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
-    console.error(error)
     return error
   }
 }

database/Models/Mentions.js

@@ -1,85 +1,62 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 
 async function createMention(nom, uniter) {
-  const sql = 'INSERT INTO mentions (nom, uniter) VALUES (?, ?)'
+  const query = database.prepare('INSERT INTO mentions (nom, uniter) VALUES (?, ?)')
 
   try {
-    let [result] = await pool.query(sql, [nom, uniter])
+    let response = await query.run(nom, uniter)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
 async function deleteMention(id) {
-  const sql = 'DELETE FROM mentions WHERE id = ?'
+  const query = database.prepare('DELETE FROM mentions WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [id])
+    let response = await query.run(id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
 async function getMentions() {
-  const sql = 'SELECT * FROM mentions'
+  const query = database.prepare('SELECT * FROM mentions')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = await query.all()
 
-    return rows
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
 async function getSingleMention(id) {
-  const sql = 'SELECT * FROM mentions WHERE id = ?'
+  const query = database.prepare('SELECT * FROM mentions WHERE id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = query.get(id)
 
-    return rows[0]
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
 async function updateMention(nom, uniter, id) {
-  const sql = 'UPDATE mentions SET nom = ?, uniter = ? WHERE id = ?'
+  const query = database.prepare('UPDATE mentions SET nom = ?, uniter = ? WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [nom, uniter, id])
+    let response = query.run(nom, uniter, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé ou aucune modification effectuée.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire mis à jour avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 

database/Models/Niveau.js

@@ -1,4 +1,4 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 
 /**
  * function to insert niveau to database
@@ -15,15 +15,14 @@ async function insertNiveau(nom) {
   }
 
   // Prepare the query for insertion
-  const sql = `INSERT INTO niveaus (nom) VALUES (?)`
+  const query = database.prepare('INSERT INTO niveaus (nom) VALUES (?)')
 
   try {
     let responses = []
-
     for (const name of nom_multiple) {
       // Insert each name and collect the response
-      const [result] = await pool.query(sql, [name])
+      let response = await query.run(name)
-      responses.push(result)
+      responses.push(response)
     }
     if (nom_multiple.length === responses.length) {
       return JSON.stringify({
@@ -32,7 +31,7 @@ async function insertNiveau(nom) {
       })
     } else return false
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error // Return the error if any occurs
   }
 }
 
@@ -42,18 +41,14 @@ async function insertNiveau(nom) {
  * @returns Promise
  */
 async function getSingleNiveau(id) {
-  const sql = 'SELECT * FROM niveaus WHERE id = ?'
+  const query = database.prepare('SELECT * FROM niveaus WHERE id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = await query.get(id)
 
-    if (rows.length > 0) {
+    return response
-      return rows[0]
-    } else {
-      return null
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
@@ -64,24 +59,14 @@ async function getSingleNiveau(id) {
  * @returns Promise
  */
 async function updateNiveau(nom, id) {
-  const sql = 'UPDATE niveaus SET nom = ? WHERE id = ?'
+  const query = database.prepare('UPDATE niveaus SET nom = ? WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [nom, id])
+    let response = query.run(nom, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Niveau non trouvé ou aucune modification effectuée.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Utilisateur mis à jour avec succès.'
-    }
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' + error }
+    return error
   }
 }
 
@@ -89,39 +74,26 @@ async function updateNiveau(nom, id) {
  * function to get all niveau
  */
 async function getNiveau() {
-  const sql = 'SELECT * FROM niveaus'
+  const query = database.prepare('SELECT * FROM niveaus')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = query.all()
 
-    return rows
+    return response
   } catch (error) {
-    return { success: false, error: 'Erreur veullez réeseyer' }
+    return error
   }
 }
 
 async function deleteNiveau(id) {
-  const sql = 'DELETE FROM niveaus WHERE id = ?'
+  const query = database.prepare('DELETE FROM niveaus WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [id])
+    let response = await query.run(id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Niveau non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Niveau supprimé avec succès.'
-    }
   } catch (error) {
-    return {
+    return error
-      success: false,
-      error: 'Erreur lors de la suppression, veuillez réessayer.'
-    }
   }
 }
 

database/Models/NoteRepechage.js

@@ -1,4 +1,4 @@
-const { database } = require('../database.backup')
+const { database } = require('../database')
 const { getNiveau } = require('./Niveau')
 const { matiereSysteme } = require('../function/System')
 

database/Models/NoteSysrem.js

@@ -1,4 +1,4 @@
-const { database } = require('../database.backup')
+const { database } = require('../database')
 
 /**
  * function to get all Systeme note

database/Models/Notes.js

@@ -1,4 +1,4 @@
-const { database } = require('../database.backup')
+const { database } = require('../database')
 const { getNiveau } = require('./Niveau')
 const { matiereSysteme } = require('../function/System')
 

database/Models/Parcours.js

@@ -1,221 +1,169 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 const { matiereSystemReverse } = require('../function/System')
 const dayjs = require('dayjs')
 
 async function insertParcour(nom, uniter, mention_id) {
-  const sql = 'INSERT INTO parcours (nom, uniter, mention_id) VALUES (?, ?, ?)'
+  const query = database.prepare('INSERT INTO parcours (nom, uniter, mention_id) VALUES (?, ?, ?)')
 
   try {
-    let [result] = await pool.query(sql, [nom, uniter, mention_id == null ? 0 : mention_id])
+    let response = query.run(nom, uniter, mention_id == null ? 0 : mention_id)
 
-    return {
+    return response
-      success: true,
-      id: result.insertId
-    }
   } catch (error) {
     return error
   }
 }
 
 async function getParcourMatiere(id) {
-  const sql = `SELECT * FROM parcoursmatiere WHERE matiere_id = ?`
+  const parcourMatiereQuery = database.prepare('SELECT * FROM parcoursmatiere WHERE matiere_id = ?')
 
   try {
-    const [rows] = await pool.query(sql, [id])
+    let response
-    return rows
+    return (response = await parcourMatiereQuery.all(id))
   } catch (error) {
-    console.error(error)
     return error
   }
 }
 
 async function getParcours() {
-  const sql = 'SELECT * FROM parcours ORDER BY id DESC'
+  const query = database.prepare('SELECT * FROM parcours ORDER BY id DESC')
 
   try {
-    let [rows] = await pool.query(sql)
+    let response = query.all()
 
-    return rows
+    return response
   } catch (error) {
     return error
   }
 }
 
 async function getSingleParcours(id) {
-  const sql = 'SELECT * FROM parcours WHERE id = ?'
+  const query = database.prepare('SELECT * FROM parcours WHERE id = ?')
 
   try {
-    let [rows] = await pool.query(sql, [id])
+    let response = await query.get(id)
 
-    return rows[0]
+    return response
   } catch (error) {
     return error
   }
 }
 
 async function deletes(id) {
-  const sql = 'DELETE FROM parcours WHERE id = ?'
+  const query = database.prepare('DELETE FROM parcours WHERE id = ?')
 
   try {
-    let [result] = await pool.query(sql, [id])
+    let response = await query.run(id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire supprimé avec succès.'
-    }
   } catch (error) {
     return error
   }
 }
 
 async function updateparcour(id, nom, uniter, mention_id) {
-  const sql = 'UPDATE parcours SET nom = ?, uniter = ?, mention_id = ? WHERE id = ?'
+  const query = database.prepare(
+    'UPDATE parcours SET nom = ?, uniter = ?, mention_id = ? WHERE id = ?'
+  )
 
   try {
-    let [result] = await pool.query(sql, [nom, uniter, mention_id, id])
+    let response = await query.run(nom, uniter, mention_id, id)
 
-    if (result.affectedRows === 0) {
+    return response
-      return {
-        success: false,
-        message: 'Année universitaire non trouvé ou aucune modification effectuée.'
-      }
-    }
-
-    return {
-      success: true,
-      message: 'Année universitaire mis à jour avec succès.'
-    }
   } catch (error) {
     return error
   }
 }
 
-async function parcourMatiere(matiere_id, parcour_ids) {
+async function parcourMatiere(matiere_id, parcour_id) {
+  const query = database.prepare(
+    'INSERT INTO parcoursmatiere (matiere_id, parcour_id) VALUES (?, ?)'
+  )
+
+  database.prepare('DELETE FROM parcoursmatiere WHERE matiere_id = ?').run(matiere_id)
+
   try {
-    // 1. Delete all existing relations for this matiere
+    let response
-    const deleteSql = `DELETE FROM parcoursmatiere WHERE matiere_id = ?`
+    database.transaction(() => {
-    await pool.query(deleteSql, [matiere_id])
+      for (let index = 0; index < parcour_id.length; index++) {
+        response = query.run(matiere_id, parcour_id[index])
+      }
+    })()
 
-    // 2. Insert new relations
+    return response
-    if (parcour_ids.length === 0) {
-      return { success: true, message: 'No parcours to insert' }
-    }
-
-    const insertSql = `
-      INSERT INTO parcoursmatiere (matiere_id, parcour_id)
-      VALUES ${parcour_ids.map(() => '(?, ?)').join(',')}
-    `
-
-    // Flatten values like: [matiere_id, parcour_id1, matiere_id, parcour_id2, ...]
-    const values = parcour_ids.flatMap((pid) => [matiere_id, pid])
-
-    const [result] = await pool.query(insertSql, values)
-
-    return { success: true, affectedRows: result.affectedRows }
   } catch (error) {
-    console.error(error)
+    return error
-    return { success: false, error: error.message }
   }
 }
 
 async function extractFiche(matiere_id) {
-  const now = dayjs().format('YYYY')
+  const query = database.prepare(
+    'SELECT matiere_semestre.semestre_id, matiere_semestre.mention_id, semestres.* FROM matiere_semestre INNER JOIN semestres ON (matiere_semestre.semestre_id = semestres.id) WHERE matiere_semestre.matiere_id = ?'
+  )
+  const allStudentQuery = database.prepare(
+    'SELECT * FROM etudiants WHERE niveau LIKE ? AND annee_scolaire LIKE ?'
+  )
+  const parcourMatiereQuery = database.prepare(
+    'SELECT * FROM parcoursmatiere INNER JOIN parcours ON (parcoursmatiere.parcour_id = parcours.id) WHERE parcoursmatiere.matiere_id = ?'
+  )
 
-  const connection = await pool.getConnection()
   try {
-    await connection.beginTransaction()
+    let matiereSemestre = query.all(matiere_id)
-
-    // Get semestre and mention
-    const [matiereSemestre] = await connection.query(
-      `
-      SELECT matiere_semestre.semestre_id, matiere_semestre.mention_id, semestres.*
-      FROM matiere_semestre
-      INNER JOIN semestres ON matiere_semestre.semestre_id = semestres.id
-      WHERE matiere_semestre.matiere_id = ?
-      `,
-      [matiere_id]
-    )
-
-    // Get parcours
-    const [parcours] = await connection.query(
-      `
-      SELECT * FROM parcoursmatiere
-      INNER JOIN parcours ON parcoursmatiere.parcour_id = parcours.id
-      WHERE parcoursmatiere.matiere_id = ?
-      `,
-      [matiere_id]
-    )
-
     let response = []
+    let allSTudent = []
     let allMention_id = []
+    let realSponse = []
+    let now = dayjs().format('YYYY')
 
-    for (let index = 0; index < matiereSemestre.length; index++) {
+    realSponse = await database.transaction(async () => {
-      response.push(await matiereSystemReverse(matiereSemestre[index].nom))
+      let parcours = parcourMatiereQuery.all(Number(matiere_id))
-      allMention_id.push(matiereSemestre[index].mention_id)
+      for (let index = 0; index < matiereSemestre.length; index++) {
-    }
+        response.push(await matiereSystemReverse(matiereSemestre[index].nom))
-
+        allMention_id.push(matiereSemestre[index].mention_id)
-    // Remove duplicates
-    let newResponse = []
-    for (let index = 0; index < response.length; index++) {
-      if (response[index] !== response[index + 1]) {
-        newResponse.push(response[index])
       }
-    }
 
-    // Get all students for the matched niveau and school year
+      let newResponse = []
-    let allStudents = []
+      for (let index = 0; index < response.length; index++) {
-    for (let index = 0; index < newResponse.length; index++) {
+        if (response[index] != response[index + 1]) {
-      const [students] = await connection.query(
+          newResponse.push(response[index])
-        `
+        }
-        SELECT * FROM etudiants
+      }
-        WHERE niveau LIKE ? AND annee_scolaire LIKE ?
-        `,
-        [`%${newResponse[index]}%`, `%${now}%`]
-      )
-      allStudents.push(...students)
-    }
 
-    // Filter students by mention
+      for (let index = 0; index < newResponse.length; index++) {
-    const studentFiltredMention = allStudents.filter((etudiant) =>
+        allSTudent = allStudentQuery.all(`%${newResponse[index]}%`, `%${now}%`)
-      allMention_id.includes(etudiant.mention_id)
+      }
-    )
 
-    // Filter by parcours
+      let studentFiltredMention = []
-    let allData = []
+      for (let index = 0; index < allSTudent.length; index++) {
+        if (allMention_id.includes(allSTudent[index].mention_id)) {
+          studentFiltredMention.push(allSTudent[index])
+        }
+      }
+      let allData = []
 
-    for (let j = 0; j < parcours.length; j++) {
+      for (let j = 0; j < parcours.length; j++) {
-      for (let index = 0; index < studentFiltredMention.length; index++) {
+        for (let index = 0; index < studentFiltredMention.length; index++) {
-        const currentStudent = studentFiltredMention[index]
+          if (parcours[j].parcour_id == 1) {
-        const parcoursName = parcours[j].nom
+            if (
-        const parcour_id = parcours[j].parcour_id
+              studentFiltredMention[index].parcours == null ||
-
+              studentFiltredMention[index].parcours == parcours[j].nom
-        if (parcour_id == 1) {
+            ) {
-          if (currentStudent.parcours == null || currentStudent.parcours == parcoursName) {
+              allData.push(studentFiltredMention[index])
-            allData.push(currentStudent)
+            }
-          }
+          } else {
-        } else {
+            if (studentFiltredMention[index].parcours == parcours[j].nom) {
-          if (currentStudent.parcours == parcoursName) {
+              allData.push(studentFiltredMention[index])
-            allData.push(currentStudent)
+            }
           }
         }
       }
-    }
 
-    await connection.commit()
+      return allData
-    connection.release()
+    })()
-    return allData
+
+    return realSponse
   } catch (error) {
-    await connection.rollback()
+    return error
-    connection.release()
-    console.error(error)
-    return { success: false, error: error.message }
   }
 }
 

database/Models/Status.js

@@ -1,4 +1,4 @@
-const { database } = require('../database.backup')
+const { database } = require('../database')
 
 /**
  * function to return all status

database/Models/Users.backup.js

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

database/database.backup.js

@@ -1,444 +0,0 @@
-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,307 +1,444 @@
-const mysql = require('mysql2/promise')
+const sqlite = require('better-sqlite3')
 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() {
+// Construct the database path using the detected IP
-  const connection = await pool.getConnection()
+let dbPath = `./base/data.db`;
 
-  try {
+// Connect to SQLite database with the initial path
-    // Users table
+let database = new sqlite(dbPath);
-    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) UNIQUE 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 UNIQUE 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 the users table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS matieres (
+const createUserTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS users (
-        nom VARCHAR(250) UNIQUE NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        unite_enseignement VARCHAR(250) NOT NULL,
+    username VARCHAR(200) NOT NULL,
-        credit INT NOT NULL,
+    email VARCHAR(250) NOT NULL UNIQUE,
-        heure INT NOT NULL,
+    password TEXT NOT NULL,
-        ue VARCHAR(10) NOT NULL,
+    roles VARCHAR(250) NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      ) ENGINE=InnoDB;
+  );
-    `)
+`
+database.prepare(createUserTableQuery).run()
 
-    await connection.query(`
+// Insert a default admin user if not exists
-      CREATE TABLE IF NOT EXISTS semestres (
+const insertDefaultUserQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  INSERT INTO users (username, email, password, roles)
-        nom VARCHAR(30) NOT NULL,
+  SELECT 'admin', 'admin@example.com', ?, 'admin'
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = 'admin');
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+`
-      ) ENGINE=InnoDB;
-    `)
 
-    await connection.query(`
+// Hash the password '1234' before storing
-      CREATE TABLE IF NOT EXISTS matiere_mention (
+const hashedPassword = bcrypt.hashSync('123456789', 10)
-        id INT AUTO_INCREMENT PRIMARY KEY,
+database.prepare(insertDefaultUserQuery).run(hashedPassword)
-        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 for note status
-      CREATE TABLE IF NOT EXISTS matiere_semestre (
+const createStatusTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS status (
-        matiere_id INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        semestre_id INT NOT NULL,
+    nom VARCHAR(200) NOT NULL,
-        mention_id INT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        FOREIGN KEY (semestre_id) REFERENCES semestres(id),
+  );
-        FOREIGN KEY (mention_id) REFERENCES mentions(id)
+`
-      ) ENGINE=InnoDB;
+database.prepare(createStatusTableQuery).run()
-    `)
 
-    await connection.query(`
+// create table for mention
-      CREATE TABLE IF NOT EXISTS notes (
+const createMentionTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS mentions (
-        etudiant_id INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        matiere_id INT NOT NULL,
+    nom VARCHAR(250) NOT NULL,
-        etudiant_niveau VARCHAR(50) NOT NULL,
+    uniter VARCHAR(50) NOT NULL, -- Abréviation du nom
-        mention_id INT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        note FLOAT DEFAULT NULL,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        annee_scolaire VARCHAR(50) NOT NULL,
+  );
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+`
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+database.prepare(createMentionTableQuery).run()
-        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 the niveau table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS notesrepech (
+const createNiveauTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS niveaus (
-        etudiant_id INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        matiere_id INT NOT NULL,
+    nom VARCHAR(50) NOT NULL, -- Exemple: L1, L2, L3, etc.
-        etudiant_niveau VARCHAR(50) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        mention_id INT NOT NULL,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        note FLOAT DEFAULT NULL,
+  );
-        annee_scolaire VARCHAR(50) NOT NULL,
+`
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+database.prepare(createNiveauTableQuery).run()
-        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 the etudiants table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS notesystems (
+const createEtudiantsTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS etudiants (
-        admis FLOAT NOT NULL DEFAULT 10,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        redouble FLOAT NOT NULL DEFAULT 9.99,
+    nom VARCHAR(250) DEFAULT NULL,
-        renvoyer FLOAT NOT NULL DEFAULT 7.99,
+    prenom VARCHAR(250) DEFAULT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    photos TEXT DEFAULT NULL,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    date_de_naissances DATE DEFAULT NULL,
-      ) ENGINE=InnoDB;
+    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()
 
-    await connection.query(`
+// Create the notes table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS anneescolaire (
+const createMatiereTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS matieres (
-        code VARCHAR(30) NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        debut DATE NOT NULL,
+    nom VARCHAR(250) UNIQUE NOT NULL,
-        fin DATE NOT NULL,
+    unite_enseignement VARCHAR(250) NOT NULL,
-        is_current TINYINT(1) DEFAULT 0,
+    credit INTEGER NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    heure INTEGER NOT NULL,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    ue VARCHAR(10) NOT NULL,
-      ) ENGINE=InnoDB;
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    `)
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createMatiereTableQuery).run()
 
-    await connection.query(`
+// Create the semestre table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS traitmentsystem (
+const createSemestreTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS semestres (
-        code VARCHAR(30) NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        debut DATE NOT NULL,
+    nom VARCHAR(30) NOT NULL, -- Exemple: S1, S2, S3, etc.
-        fin DATE NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        is_finished TINYINT(1) DEFAULT 0,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  );
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+`
-      ) ENGINE=InnoDB;
+database.prepare(createSemestreTableQuery).run()
-    `)
 
-    await connection.query(`
+// Create the semestre table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS nessesaryTable (
+const createMatiere_mentionTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS matiere_mention (
-        uniter_heure INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    mention_id INTEGER NOT NULL, -- Clé étrangère vers mentions
-      ) ENGINE=InnoDB;
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id),
-    `)
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
+  );
+`
+database.prepare(createMatiere_mentionTableQuery).run()
 
-    await connection.query(`
+const createMatiere_semestreTableQuery = `
-      CREATE TABLE IF NOT EXISTS matiereEnseignants (
+  CREATE TABLE IF NOT EXISTS matiere_semestre (
-        id INT AUTO_INCREMENT PRIMARY KEY,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        matiere_id INT NOT NULL,
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
-        nom_enseignant VARCHAR(250) NOT NULL,
+    semestre_id INTEGER NOT NULL, -- Clé étrangère vers semestres
-        prenom_enseignant VARCHAR(250) NOT NULL,
+    mention_id INTEGER NOT NULL, -- Clé étrangère vers niveaus
-        contact VARCHAR(11) NOT NULL,
+    FOREIGN KEY (matiere_id) REFERENCES matieres(id),
-        date DATE NOT NULL,
+    FOREIGN KEY (semestre_id) REFERENCES semestres(id),
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (mention_id) REFERENCES mentions(id)
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  );
-        FOREIGN KEY (matiere_id) REFERENCES matieres(id)
+`
-      ) ENGINE=InnoDB;
+database.prepare(createMatiere_semestreTableQuery).run()
-    `)
 
-    await connection.query(`
+// Create the notes table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS parcours (
+const createNoteTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS notes (
-        nom VARCHAR(250) NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        uniter VARCHAR(250) NOT NULL,
+    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
-        mention_id INT DEFAULT NULL,
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    etudiant_niveau VARCHAR(50) NOT NULL,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    mention_id INTEGER NOT NULL,
-      ) ENGINE=InnoDB;
+    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()
 
-    await connection.query(`
+// Create the notes second session table if it doesn't exist
-      CREATE TABLE IF NOT EXISTS parcoursmatiere (
+const createNoteRepechTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS notesrepech (
-        matiere_id INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        parcour_id INT NOT NULL,
+    etudiant_id INTEGER NOT NULL, -- Clé étrangère vers etudiants
-        FOREIGN KEY (matiere_id) REFERENCES matieres(id),
+    matiere_id INTEGER NOT NULL, -- Clé étrangère vers matieres
-        FOREIGN KEY (parcour_id) REFERENCES parcours(id)
+    etudiant_niveau VARCHAR(50) NOT NULL,
-      ) ENGINE=InnoDB;
+    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()
 
-    await connection.query(`
+// create table for note système
-      CREATE TABLE IF NOT EXISTS trancheecolage (
+const createNoteSystemeTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS notesystems (
-        etudiant_id INT NOT NULL,
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-        tranchename VARCHAR(255) NOT NULL,
+    admis FLOAT NOT NULL DEFAULT 10,
-        montant DOUBLE NOT NULL
+    redouble FLOAT NOT NULL DEFAULT 9.99,
-      ) ENGINE=InnoDB;
+    renvoyer FLOAT NOT NULL DEFAULT 7.99,
-    `)
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createNoteSystemeTableQuery).run()
 
-    await connection.query(`
+// create table année scolaire
-      CREATE TABLE IF NOT EXISTS ipconfig (
+const createAnneeScolaireTableQuery = `
-        id INT AUTO_INCREMENT PRIMARY KEY,
+  CREATE TABLE IF NOT EXISTS anneescolaire (
-        ipname VARCHAR(255) NOT NULL
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-      ) ENGINE=InnoDB;
+    code VARCHAR(30) NOT NULL,
-    `)
+    debut DATE NOT NULL,
-  } finally {
+    fin DATE NOT NULL,
-    connection.release()
+    is_current INTEGER DEFAULT 0,
-  }
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-}
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+`
+database.prepare(createAnneeScolaireTableQuery).run()
 
-async function insertDefaultAdmin() {
+// create traitement systeme
-  const conn = await pool.getConnection()
+const createTraitementSystemQuery = `
-  try {
+  CREATE TABLE IF NOT EXISTS traitmentsystem (
-    const [rows] = await conn.query(`SELECT COUNT(*) as count FROM users WHERE username = ?`, [
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-      'admin'
+    code VARCHAR(30) NOT NULL,
-    ])
+    debut DATE NOT NULL,
-    if (rows[0].count === 0) {
+    fin DATE NOT NULL,
-      const hashedPassword = bcrypt.hashSync('123456789', 10)
+    is_finished INTEGER DEFAULT 0,
-      await conn.query(
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        `
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        INSERT INTO users (username, email, password, roles)
+  );
-        VALUES (?, ?, ?, ?)`,
+`
-        ['admin', 'admin@example.com', hashedPassword, 'admin']
+database.prepare(createTraitementSystemQuery).run()
-      )
+
-    }
+const createNecessaryParameterTableQuery = `
-  } finally {
+  CREATE TABLE IF NOT EXISTS nessesaryTable (
-    conn.release()
+    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() {
-  const conn = await pool.getConnection()
+  // Préparation des requêtes
-  try {
+  const checkStatusQuery = database.prepare(`
-    const statuses = ['Nouveau', 'Passant', 'Redoublant', 'Renvoyé', 'Ancien']
+    SELECT COUNT(*) AS count FROM status WHERE nom = ?;
-    for (let name of statuses) {
+  `)
-      const [rows] = await conn.query(`SELECT COUNT(*) as count FROM status WHERE nom = ?`, [name])
+  const insertStatusQuery = database.prepare(`
-      if (rows[0].count === 0) {
+    INSERT INTO status (nom) VALUES (?);
-        await conn.query(`INSERT INTO status (nom) VALUES (?)`, [name])
+  `)
-      }
+
+  // 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)
     }
-  } finally {
-    conn.release()
   }
 }
+// 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 = {
-  pool,
+  database
-  createTables,
-  insertDefaultAdmin,
-  insertStatusesIfNotExist
 }

database/database2.js

@@ -1,307 +0,0 @@
-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
-}

database/function/System.js

@@ -1,261 +1,261 @@
-const { pool } = require('../database')
+const { database } = require('../database')
 const dayjs = require('dayjs')
 
 async function updateCurrentYears() {
   const fullDate = dayjs().format('YYYY-MM-DD')
 
   // Clear current year flag
-  const clearCurrent = 'UPDATE anneescolaire SET is_Current = 0 WHERE id > 0'
+  const clearCurrent = database.prepare('UPDATE anneescolaire SET is_Current = 0 WHERE id > 0')
-  pool.query(clearCurrent)
+  clearCurrent.run()
 
   // Set the new current year
-  const updateCurrent = `
+  const updateCurrent = database.prepare(`
     UPDATE anneescolaire
     SET is_Current = 1
     WHERE ? >= debut AND ? <= fin
-  `
+  `)
   // console.log();
-  pool.query(updateCurrent, [fullDate, fullDate])
+  updateCurrent.run(fullDate, fullDate)
 
   // Check if the update was successful
-  const sql = `
+  const check = database
-      SELECT * FROM anneescolaire
+    .prepare(
-      WHERE ? >= debut AND ? <= fin
+      `
-    `
+    SELECT * FROM anneescolaire
-  const [rows] = await pool.query(sql, [fullDate, fullDate])
+    WHERE ? >= debut AND ? <= fin
+  `
+    )
+    .get(fullDate, fullDate)
 
-  const check = rows[0]
+  // Insert into traitmentsystem if a current year exists
-  if (!check) return
+  if (check) {
-
+    let search = database.prepare('SELECT * FROM traitmentsystem WHERE code = ?').get(check.code)
-  // 2. Check if already in traitmentsystem
+    console.log(search)
-  const searchSql = `SELECT * FROM traitmentsystem WHERE code = ?`
+    if (!search) {
-  const [searchRows] = await pool.query(searchSql, [check.code])
+      const insertQuery = database.prepare(`
-
-  if (searchRows.length === 0) {
-    // 3. Insert into traitmentsystem
-    const insertSql = `
         INSERT INTO traitmentsystem (code, debut, fin)
         VALUES (?, ?, ?)
-      `
+      `)
-    await pool.query(insertSql, [check.code, check.debut, check.fin])
+      insertQuery.run(check.code, check.debut, check.fin)
+    }
   } else {
     console.log('No active school year found for the current date.')
   }
 }
 
-// async function updateStudents() {
+async function updateStudents() {
-//   const getInfinishedYears = database
+  const getInfinishedYears = database
-//     .prepare('SELECT * FROM traitmentsystem WHERE is_finished = 0 ORDER BY id ASC')
+    .prepare('SELECT * FROM traitmentsystem WHERE is_finished = 0 ORDER BY id ASC')
-//     .get()
+    .get()
 
-//   const allEtudiants = database
+  const allEtudiants = database
-//     .prepare('SELECT * FROM etudiants WHERE annee_scolaire = ?')
+    .prepare('SELECT * FROM etudiants WHERE annee_scolaire = ?')
-//     .all(getInfinishedYears.code)
+    .all(getInfinishedYears.code)
 
-//   function checkNull(params) {
+  function checkNull(params) {
-//     if (params == null || params == undefined) {
+    if (params == null || params == undefined) {
-//       return null
+      return null
-//     }
+    }
-//     return params
+    return params
-//   }
+  }
 
-//   function compareSessionNotes(session1, session2) {
+  function compareSessionNotes(session1, session2) {
-//     let notes
+    let notes
-//     if (session2) {
+    if (session2) {
-//       if (session1 < session2.note) {
+      if (session1 < session2.note) {
-//         notes = session2.note
+        notes = session2.note
-//       } else {
+      } else {
-//         notes = session1
+        notes = session1
-//       }
+      }
-//     } else {
+    } else {
-//       notes = session1
+      notes = session1
-//     }
+    }
-//     return notes
+    return notes
-//   }
+  }
 
-//   database.transaction(() => {
+  database.transaction(() => {
-//     // get all note of student
+    // get all note of student
-//     const queryNotes = database.prepare(
+    const queryNotes = database.prepare(
-//       `SELECT DISTINCT etudiant_id FROM notes WHERE etudiant_niveau = ? AND annee_scolaire = ?`
+      `SELECT DISTINCT etudiant_id FROM notes WHERE etudiant_niveau = ? AND annee_scolaire = ?`
-//     )
+    )
-//     let allEtudiantWithNotes = []
+    let allEtudiantWithNotes = []
-//     let etudiantWithNotes = []
+    let etudiantWithNotes = []
-//     let dataToMap = []
+    let dataToMap = []
-//     let allEtudiantWithNotesRepech = []
+    let allEtudiantWithNotesRepech = []
-//     let etudiantWithNotesRepech = []
+    let etudiantWithNotesRepech = []
 
-//     for (const etudiant of allEtudiants) {
+    for (const etudiant of allEtudiants) {
-//       const results = queryNotes.all(etudiant.niveau, etudiant.annee_scolaire)
+      const results = queryNotes.all(etudiant.niveau, etudiant.annee_scolaire)
-//       etudiantWithNotes.push(...results) // Avoid nested arrays
+      etudiantWithNotes.push(...results) // Avoid nested arrays
-//     }
+    }
 
-//     const uniqueId = etudiantWithNotes.filter(
+    const uniqueId = etudiantWithNotes.filter(
-//       (item, index, self) => index === self.findIndex((t) => t.etudiant_id === item.etudiant_id)
+      (item, index, self) => index === self.findIndex((t) => t.etudiant_id === item.etudiant_id)
-//     )
+    )
 
-//     const query2 = database.prepare(
+    const query2 = database.prepare(
-//       'SELECT notes.*, etudiants.*, matieres.id, matieres.nom AS nomMat, matieres.credit FROM notes LEFT JOIN etudiants ON (notes.etudiant_id = etudiants.id) LEFT JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ?'
+      'SELECT notes.*, etudiants.*, matieres.id, matieres.nom AS nomMat, matieres.credit FROM notes LEFT JOIN etudiants ON (notes.etudiant_id = etudiants.id) LEFT JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ?'
-//     )
+    )
 
-//     for (let j = 0; j < uniqueId.length; j++) {
+    for (let j = 0; j < uniqueId.length; j++) {
-//       allEtudiantWithNotes.push(query2.all(uniqueId[j].etudiant_id))
+      allEtudiantWithNotes.push(query2.all(uniqueId[j].etudiant_id))
-//     }
+    }
 
-//     const query = database.prepare(
+    const query = database.prepare(
-//       `SELECT DISTINCT etudiant_id FROM notesrepech WHERE etudiant_niveau = ? AND annee_scolaire = ?`
+      `SELECT DISTINCT etudiant_id FROM notesrepech WHERE etudiant_niveau = ? AND annee_scolaire = ?`
-//     )
+    )
 
-//     for (const etudiant of allEtudiants) {
+    for (const etudiant of allEtudiants) {
-//       const results = query.all(etudiant.niveau, etudiant.annee_scolaire)
+      const results = query.all(etudiant.niveau, etudiant.annee_scolaire)
-//       etudiantWithNotesRepech.push(...results) // Avoid nested arrays
+      etudiantWithNotesRepech.push(...results) // Avoid nested arrays
-//     }
+    }
 
-//     const uniqueIdRepech = etudiantWithNotes.filter(
+    const uniqueIdRepech = etudiantWithNotes.filter(
-//       (item, index, self) => index === self.findIndex((t) => t.etudiant_id === item.etudiant_id)
+      (item, index, self) => index === self.findIndex((t) => t.etudiant_id === item.etudiant_id)
-//     )
+    )
 
-//     const query2Repech = database.prepare(
+    const query2Repech = database.prepare(
-//       'SELECT notesrepech.*, etudiants.*, matieres.id, matieres.nom AS nomMat, matieres.credit FROM notesrepech INNER JOIN etudiants ON (notesrepech.etudiant_id = etudiants.id) INNER JOIN matieres ON (notesrepech.matiere_id = matieres.id) WHERE notesrepech.etudiant_id = ?'
+      'SELECT notesrepech.*, etudiants.*, matieres.id, matieres.nom AS nomMat, matieres.credit FROM notesrepech INNER JOIN etudiants ON (notesrepech.etudiant_id = etudiants.id) INNER JOIN matieres ON (notesrepech.matiere_id = matieres.id) WHERE notesrepech.etudiant_id = ?'
-//     )
+    )
 
-//     for (let j = 0; j < uniqueIdRepech.length; j++) {
+    for (let j = 0; j < uniqueIdRepech.length; j++) {
-//       allEtudiantWithNotesRepech.push(query2Repech.all(uniqueIdRepech[j].etudiant_id))
+      allEtudiantWithNotesRepech.push(query2Repech.all(uniqueIdRepech[j].etudiant_id))
-//     }
+    }
 
-//     for (let index = 0; index < allEtudiantWithNotes.length; index++) {
+    for (let index = 0; index < allEtudiantWithNotes.length; index++) {
-//       let total = 0
+      let total = 0
-//       let note = 0
+      let note = 0
-//       let totalCredit = 0
+      let totalCredit = 0
 
-//       // Create a new object for each student
+      // Create a new object for each student
-//       let modelJson = {
+      let modelJson = {
-//         id: '',
+        id: '',
-//         nom: '',
+        nom: '',
-//         prenom: '',
+        prenom: '',
-//         photos: '',
+        photos: '',
-//         moyenne: '',
+        moyenne: '',
-//         mention: '',
+        mention: '',
-//         niveau: '',
+        niveau: '',
-//         annee_scolaire: ''
+        annee_scolaire: ''
-//       }
+      }
 
-//       for (let j = 0; j < allEtudiantWithNotes[index].length; j++) {
+      for (let j = 0; j < allEtudiantWithNotes[index].length; j++) {
-//         modelJson.id = allEtudiantWithNotes[index][j].etudiant_id
+        modelJson.id = allEtudiantWithNotes[index][j].etudiant_id
-//         modelJson.nom = allEtudiantWithNotes[index][j].nom
+        modelJson.nom = allEtudiantWithNotes[index][j].nom
-//         modelJson.prenom = allEtudiantWithNotes[index][j].prenom
+        modelJson.prenom = allEtudiantWithNotes[index][j].prenom
-//         modelJson.photos = allEtudiantWithNotes[index][j].photos
+        modelJson.photos = allEtudiantWithNotes[index][j].photos
-//         modelJson.mention = allEtudiantWithNotes[index][j].mention_id
+        modelJson.mention = allEtudiantWithNotes[index][j].mention_id
-//         modelJson.niveau = allEtudiantWithNotes[index][j].niveau
+        modelJson.niveau = allEtudiantWithNotes[index][j].niveau
-//         modelJson.annee_scolaire = allEtudiantWithNotes[index][j].annee_scolaire
+        modelJson.annee_scolaire = allEtudiantWithNotes[index][j].annee_scolaire
 
-//         // console.log(checkNull(session[index][j]));
+        // console.log(checkNull(session[index][j]));
-//         if (allEtudiantWithNotesRepech[index]) {
+        if (allEtudiantWithNotesRepech[index]) {
-//           note +=
+          note +=
-//             compareSessionNotes(
+            compareSessionNotes(
-//               allEtudiantWithNotes[index][j].note,
+              allEtudiantWithNotes[index][j].note,
-//               checkNull(allEtudiantWithNotesRepech[index][j])
+              checkNull(allEtudiantWithNotesRepech[index][j])
-//             ) * allEtudiantWithNotes[index][j].credit
+            ) * allEtudiantWithNotes[index][j].credit
-//         } else {
+        } else {
-//           note += allEtudiantWithNotes[index][j].note * allEtudiantWithNotes[index][j].credit
+          note += allEtudiantWithNotes[index][j].note * allEtudiantWithNotes[index][j].credit
-//         }
+        }
-//         totalCredit += allEtudiantWithNotes[index][j].credit
+        totalCredit += allEtudiantWithNotes[index][j].credit
-//       }
+      }
 
-//       total = note / totalCredit
+      total = note / totalCredit
-//       modelJson.moyenne = total.toFixed(2)
+      modelJson.moyenne = total.toFixed(2)
 
-//       // Add the new object to the array
+      // Add the new object to the array
-//       dataToMap.push(modelJson)
+      dataToMap.push(modelJson)
-//     }
+    }
 
-//     // update all etudiant
+    // update all etudiant
-//     let updated = false
+    let updated = false
-//     if (dataToMap.length != 0) {
+    if (dataToMap.length != 0) {
-//       let noteSystem = database.prepare('SELECT * FROM notesystems').get()
+      let noteSystem = database.prepare('SELECT * FROM notesystems').get()
-//       for (let index = 0; index < dataToMap.length; index++) {
+      for (let index = 0; index < dataToMap.length; index++) {
-//         if (dataToMap[index].moyenne >= noteSystem.admis) {
+        if (dataToMap[index].moyenne >= noteSystem.admis) {
-//           let updateQuery = database.prepare(
+          let updateQuery = database.prepare(
-//             'UPDATE etudiants SET niveau = ?, annee_scolaire = ?, status = ? WHERE id = ?'
+            'UPDATE etudiants SET niveau = ?, annee_scolaire = ?, status = ? WHERE id = ?'
-//           )
+          )
-//           updateQuery.run(
+          updateQuery.run(
-//             nextLevel(dataToMap[index].niveau),
+            nextLevel(dataToMap[index].niveau),
-//             updateSchoolYear(dataToMap[index].annee_scolaire),
+            updateSchoolYear(dataToMap[index].annee_scolaire),
-//             2,
+            2,
-//             dataToMap[index].id
+            dataToMap[index].id
-//           )
+          )
-//           updated = true
+          updated = true
-//         } else if (
+        } else if (
-//           dataToMap[index].moyenne < noteSystem.admis &&
+          dataToMap[index].moyenne < noteSystem.admis &&
-//           dataToMap[index].moyenne >= noteSystem.redouble
+          dataToMap[index].moyenne >= noteSystem.redouble
-//         ) {
+        ) {
-//           let updateQuery = database.prepare(
+          let updateQuery = database.prepare(
-//             'UPDATE etudiants SET niveau = ?, annee_scolaire = ? status = ? WHERE id = ?'
+            'UPDATE etudiants SET niveau = ?, annee_scolaire = ? status = ? WHERE id = ?'
-//           )
+          )
-//           updateQuery.run(
+          updateQuery.run(
-//             dataToMap[index].niveau,
+            dataToMap[index].niveau,
-//             updateSchoolYear(dataToMap[index].annee_scolaire),
+            updateSchoolYear(dataToMap[index].annee_scolaire),
-//             3,
+            3,
-//             dataToMap[index].id
+            dataToMap[index].id
-//           )
+          )
-//           updated = true
+          updated = true
-//         } else {
+        } else {
-//           let updateQuery = database.prepare(
+          let updateQuery = database.prepare(
-//             'UPDATE etudiants SET niveau = ?, annee_scolaire = ? status = ? WHERE id = ?'
+            'UPDATE etudiants SET niveau = ?, annee_scolaire = ? status = ? WHERE id = ?'
-//           )
+          )
-//           updateQuery.run(
+          updateQuery.run(
-//             dataToMap[index].niveau,
+            dataToMap[index].niveau,
-//             dataToMap[index].annee_scolaire,
+            dataToMap[index].annee_scolaire,
-//             4,
+            4,
-//             dataToMap[index].id
+            dataToMap[index].id
-//           )
+          )
-//           updated = true
+          updated = true
-//         }
+        }
-//       }
+      }
-//     }
+    }
 
-//     if (updated) {
+    if (updated) {
-//       const updateInfinishedYears = database.prepare(
+      const updateInfinishedYears = database.prepare(
-//         'UPDATE traitmentsystem SET is_finished = 1 WHERE id = ?'
+        'UPDATE traitmentsystem SET is_finished = 1 WHERE id = ?'
-//       )
+      )
 
-//       updateInfinishedYears.run(getInfinishedYears.id)
+      updateInfinishedYears.run(getInfinishedYears.id)
-//     }
+    }
-//   })()
+  })()
-// }
+}
 
-// function nextLevel(niveau) {
+function nextLevel(niveau) {
-//   if (niveau == 'L1') {
+  if (niveau == 'L1') {
-//     return 'L2'
+    return 'L2'
-//   } else if (niveau == 'L2') {
+  } else if (niveau == 'L2') {
-//     return 'L3'
+    return 'L3'
-//   } else if (niveau == 'L3') {
+  } else if (niveau == 'L3') {
-//     return 'M1'
+    return 'M1'
-//   } else if (niveau == 'M1') {
+  } else if (niveau == 'M1') {
-//     return 'M2'
+    return 'M2'
-//   } else if (niveau == 'M2') {
+  } else if (niveau == 'M2') {
-//     return 'D1'
+    return 'D1'
-//   } else if (niveau == 'D1') {
+  } else if (niveau == 'D1') {
-//     return 'D2'
+    return 'D2'
-//   } else if (niveau == 'D2') {
+  } else if (niveau == 'D2') {
-//     return 'D3'
+    return 'D3'
-//   } else if (niveau == 'D3') {
+  } else if (niveau == 'D3') {
-//     return 'PHD'
+    return 'PHD'
-//   }
+  }
-// }
+}
 
-// function updateSchoolYear(year) {
+function updateSchoolYear(year) {
-//   // Split the year into two parts
+  // Split the year into two parts
-//   const [startYear, endYear] = year.split('-').map(Number)
+  const [startYear, endYear] = year.split('-').map(Number)
 
-//   // Increment both the start and end year by 1
+  // Increment both the start and end year by 1
-//   const newStartYear = startYear + 1
+  const newStartYear = startYear + 1
-//   const newEndYear = endYear + 1
+  const newEndYear = endYear + 1
 
-//   // Join the new years with a hyphen
+  // Join the new years with a hyphen
-//   const newYear = `${newStartYear}-${newEndYear}`
+  const newYear = `${newStartYear}-${newEndYear}`
 
-//   return newYear
+  return newYear
-// }
+}
 
 async function matiereSysteme(etudiant_niveau) {
   let systeme
@@ -300,33 +300,33 @@ async function matiereSystemReverse(semestre) {
   }
 }
 
-// async function getNessesarytable() {
+async function getNessesarytable() {
-//   try {
+  try {
-//     const query = await database.prepare('SELECT * FROM nessesaryTable').get()
+    const query = await database.prepare('SELECT * FROM nessesaryTable').get()
 
-//     return query
+    return query
-//   } catch (error) {
+  } catch (error) {
-//     return error
+    return error
-//   }
+  }
-// }
+}
 
-// async function updateNessesaryTable(id, multiplicateur) {
+async function updateNessesaryTable(id, multiplicateur) {
-//   const query = database.prepare('UPDATE nessesaryTable SET uniter_heure = ? WHERE id = ?')
+  const query = database.prepare('UPDATE nessesaryTable SET uniter_heure = ? WHERE id = ?')
 
-//   try {
+  try {
-//     let update = query.run(multiplicateur, id)
+    let update = query.run(multiplicateur, id)
 
-//     return update
+    return update
-//   } catch (error) {
+  } catch (error) {
-//     return error
+    return error
-//   }
+  }
-// }
+}
 
 module.exports = {
   matiereSysteme,
   updateCurrentYears,
-  // updateStudents,
+  updateStudents,
-  // getNessesarytable,
+  getNessesarytable,
-  // updateNessesaryTable,
+  updateNessesaryTable,
   matiereSystemReverse
 }

database/import/Matieres.js

@@ -3,7 +3,7 @@ const path = require('path')
 const XLSX = require('xlsx')
 const { parse } = require('csv-parse/sync')
 const { createMatiere } = require('../Models/Matieres')
-const { database } = require('../database.backup')
+const { database } = require('../database')
 
 /**
  * Function to import data from the first column of an XLSX or CSV file into SQLite database

jsconfig.json

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

package.json

@@ -10,7 +10,6 @@
     "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix",
     "start": "electron-vite preview",
     "dev": "electron-vite dev",
-    "test": "electronmon --exec",
     "build": "electron-vite build",
     "postinstall": "electron-builder install-app-deps",
     "build:unpack": "npm run build && electron-builder --dir",
@@ -37,7 +36,6 @@
     "@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",
@@ -54,7 +52,6 @@
     "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",
@@ -77,7 +74,6 @@
     "electron": "^31.0.2",
     "electron-builder": "^24.13.3",
     "electron-vite": "^2.3.0",
-    "electronmon": "^2.0.3",
     "eslint": "^8.57.0",
     "eslint-plugin-react": "^7.34.3",
     "npm": "^10.9.2",

src/main/backup.js

@@ -1,121 +1,31 @@
-import { app, shell, BrowserWindow, ipcMain, Tray, Menu } from 'electron'
+import { app, shell, BrowserWindow, ipcMain, Tray } from 'electron'
 import { join } from 'path'
-const path = require('path')
 import { electronApp, optimizer, is } from '@electron-toolkit/utils'
-import icon from '../../resources/logo.ico?asset' // Your tray icon file
+import icon from '../../resources/icon.png?asset'
-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 {
+const { insertNiveau } = require('../../database/Models/Niveau')
-  insertNiveau,
+const { insertNote } = require('../../database/Models/Notes')
-  updateNiveau,
-  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
+// declare mainWindow 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: 1375,
+    width: 1000,
-    minWidth: 1375,
+    minWidth: 1000,
-    height: 740,
+    height: 670,
-    minHeight: 740,
+    minHeight: 670,
     show: false,
     autoHideMenuBar: true,
-    fullscreen: false,
+    fullscreen: true, // This will make the window fullscreen when opened
-    icon: path.join(__dirname, 'resources', 'logo.ico'), // Path to your icon,
     ...(process.platform === 'linux' ? { icon } : {}),
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
@@ -125,15 +35,7 @@ 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()
   })
 
@@ -142,134 +44,44 @@ function createWindow() {
     return { action: 'deny' }
   })
 
-  // Load the appropriate URL based on environment
+  // HMR for renderer base on electron-vite cli.
+  // 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()
   })
 })
 
-// When an update is available
+// Quit when all windows are closed, except on macOS. There, it's common
-autoUpdater.on('update-available', () => {
+// for applications and their menu bar to stay active until the user quits
-  dialog.showMessageBox({
+// explicitly with Cmd + Q.
-    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()
@@ -314,9 +126,9 @@ ipcMain.handle('forgotPassword', async (event, credentials) => {
 
 // event for updating users
 ipcMain.handle('updateUsers', async (event, credentials) => {
-  const { username, newUsername, email, newEmail, passwordVerif, password, id } = credentials
+  const { username, email, passwordVerif, password, id } = credentials
 
-  const update = await updateUser(newUsername, newEmail, password, id)
+  const update = await updateUser(username, email, password, id)
 
   return update
 })
@@ -335,27 +147,8 @@ ipcMain.handle('minimize', async () => {
 
 // event for insert etudiants
 ipcMain.handle('insertEtudiant', async (event, credentials) => {
-  const {
+  const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription } =
-    nom,
+    credentials
-    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,
@@ -364,19 +157,7 @@ ipcMain.handle('insertEtudiant', async (event, credentials) => {
     date_de_naissances,
     niveau,
     annee_scolaire,
-    status,
+    num_inscription
-    num_inscription,
-    mention_id,
-    sexe,
-    nationaliter,
-    cin,
-    date_delivrence,
-    annee_bacc,
-    serie,
-    boursier,
-    domaine,
-    contact,
-    parcours
   )
 
   return insert
@@ -411,28 +192,8 @@ ipcMain.handle('insertNiveau', async (event, credentials) => {
 
 // event for updating etudiants
 ipcMain.handle('updateETudiants', async (event, credentials) => {
-  const {
+  const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription, id } =
-    nom,
+    credentials
-    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,
@@ -441,472 +202,54 @@ 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 { etudiant_id, etudiant_niveau, mention_id, formData, annee_scolaire } = credentials
+  const {
+    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,
-    etudiant_niveau,
+    Algebre,
-    mention_id,
+    Analyse,
-    formData,
+    Mecanique_Generale_I,
-    annee_scolaire
+    Resistance_Materiaux,
+    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/main/index.js

@@ -1,19 +1,11 @@
-import { app, shell, BrowserWindow, ipcMain, Tray, Menu } from 'electron'
+import { app, shell, BrowserWindow, ipcMain, Tray, Menu, screen } from 'electron'
 import { join } from 'path'
 const path = require('path')
 import { electronApp, optimizer, is } from '@electron-toolkit/utils'
 import icon from '../../resources/logo.ico?asset' // Your tray icon file
-const database = require('../../database/database')
-
-database
-  .createTables()
-  .then(() => database.insertDefaultAdmin())
-  .then(() => database.insertStatusesIfNotExist())
-  .catch(console.error)
-
-const { loginUsers } = require('../../database/Models/Users')
 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,
@@ -72,15 +64,17 @@ const {
   getSingleMention,
   updateMention
 } = require('../../database/Models/Mentions')
+const { modifyPDF } = require('../../database/function/DownloadReleverNote')
+const log = require('electron-log')
 const {
   getNoteRepech,
   updateNoteRepech,
   showMoyenRepech
 } = require('../../database/Models/NoteRepechage')
 const {
-  updateCurrentYears
+  updateCurrentYears,
-  // updateStudents,
+  updateStudents,
-  // updateNessesaryTable
+  updateNessesaryTable
 } = require('../../database/function/System')
 const { autoUpdater } = require('electron-updater')
 const { URL } = require('../../database/api/Config')
@@ -93,18 +87,20 @@ const {
   extractFiche,
   getParcourMatiere
 } = require('../../database/Models/Parcours')
+const express = require('express');
 
 // Declare mainWindow and tray in the global scope
 let mainWindow
 let tray = null
 updateCurrentYears()
-// updateStudents()
+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({
@@ -133,6 +129,7 @@ function createWindow() {
   })
 
   mainWindow.on('ready-to-show', () => {
+
     mainWindow.maximize() // Maximiser la fenêtre
     mainWindow.show()
   })
@@ -209,6 +206,7 @@ function createTray() {
               //   tray.destroy()
               // }
             }
+
           })
       }
     }
@@ -225,7 +223,7 @@ function createTray() {
 
 app.whenReady().then(() => {
   electronApp.setAppUserModelId('com.electron')
-  autoUpdater.checkForUpdatesAndNotify()
+  autoUpdater.checkForUpdatesAndNotify();
 
   app.on('browser-window-created', (_, window) => {
     optimizer.watchWindowShortcuts(window)
@@ -244,30 +242,28 @@ autoUpdater.on('update-available', () => {
   dialog.showMessageBox({
     type: 'info',
     title: 'Mise à jour disponible',
-    message: 'Une nouvelle version est disponible. Téléchargement en cours...'
+    message: 'Une nouvelle version est disponible. Téléchargement en cours...',
-  })
+  });
-})
+});
 
 // When the update is downloaded
 autoUpdater.on('update-downloaded', (info) => {
-  dialog
+  dialog.showMessageBox({
-    .showMessageBox({
+    type: 'info',
-      type: 'info',
+    title: 'Mise à jour prête',
-      title: 'Mise à jour prête',
+    message: `La version ${info.version} a été téléchargée. Redémarrer maintenant ?`,
-      message: `La version ${info.version} a été téléchargée. Redémarrer maintenant ?`,
+    buttons: ['Redémarrer', 'Plus tard'],
-      buttons: ['Redémarrer', 'Plus tard']
+  }).then((result) => {
-    })
+    if (result.response === 0) {
-    .then((result) => {
+      autoUpdater.quitAndInstall();
-      if (result.response === 0) {
+    }
-        autoUpdater.quitAndInstall()
+  });
-      }
+});
-    })
-})
 
 // If an error occurs
 autoUpdater.on('error', (error) => {
-  dialog.showErrorBox('Update Error', error == null ? 'Unknown' : error.message)
+  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', () => {
@@ -279,6 +275,48 @@ app.on('window-all-closed', () => {
 // In this file you can include the rest of your app"s specific main process
 // code. You can also put them in separate files and require them here.
 
+// Event for handling login
+ipcMain.handle('login', async (event, credentials) => {
+  const { username, password } = credentials
+
+  const users = await loginUser(username, password)
+
+  if (users) {
+    return { success: true, user: users }
+  } else {
+    return { success: false }
+  }
+})
+
+// Event for handling insert other user
+ipcMain.handle('insertUser', async (event, credentials) => {
+  const { username, email, password, roles } = credentials
+
+  const users = await insertUser(username, email, password, roles)
+
+  return users
+})
+
+// event for handlign forgot password
+ipcMain.handle('forgotPassword', async (event, credentials) => {
+  const { email, password, passwordConfirmation } = credentials
+
+  const updated = await forgotPassword(email, password, passwordConfirmation)
+
+  if (updated) {
+    return updated
+  }
+})
+
+// event for updating users
+ipcMain.handle('updateUsers', async (event, credentials) => {
+  const { username, newUsername, email, newEmail, passwordVerif, password, id } = credentials
+
+  const update = await updateUser(newUsername, newEmail, password, id)
+
+  return update
+})
+
 // event for quit app
 ipcMain.handle('quit', async () => {
   app.quit()
@@ -291,14 +329,6 @@ ipcMain.handle('minimize', async () => {
   }
 })
 
-ipcMain.handle('login', async (event, credentials) => {
-  const { username, password } = credentials
-
-  // Pass username and password to loginUsers
-  let response = await loginUsers(username, password)
-
-  return response
-})
 // event for insert etudiants
 ipcMain.handle('insertEtudiant', async (event, credentials) => {
   const {
@@ -495,7 +525,7 @@ ipcMain.handle('getMatiereByID', async (event, credentials) => {
   return matiere
 })
 
-// // event for updating matiere
+// event for updating matiere
 ipcMain.handle('updateMatiere', async (event, credentials) => {
   const { nom, credit, uniter, ue, id } = credentials
 
@@ -539,7 +569,7 @@ ipcMain.handle('createMatiere', async (event, credentials) => {
   return create
 })
 
-// // event for import excel matiere
+// event for import excel matiere
 ipcMain.handle('importExcelMatiere', async (event, credentials) => {
   const files = credentials
   console.log(files)
@@ -872,7 +902,7 @@ ipcMain.handle('createIPConfig', async (event, credentials) => {
 ipcMain.handle('updateIPConfig', async (event, credentials) => {
   const { id, ipname } = credentials
   // console.log(formData, id);
-  const get = updateIPConfig(id, ipname)
+  const get = updateIPConfig(id, ipname);
 
   return get
 })

src/preload/index.backup.js

@@ -1,210 +0,0 @@
-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,6 +5,10 @@ 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')

src/renderer/src/components/AddAnneeScolaire.jsx

@@ -40,7 +40,7 @@ const AddAnneeScolaire = () => {
     if (isValid) {
       let response = await window.anneescolaire.createAnneeScolaire(formData)
       console.log(response)
-      if (response.success) {
+      if (response.changes) {
         setStatus(200)
         setOpen(true)
       } else {

src/renderer/src/components/AddMatiere.jsx

@@ -96,8 +96,8 @@ const AddMatiere = () => {
     console.log(formData, valid)
     if (valid) {
       let response = await window.matieres.createMatiere(formData)
-      console.log(response)
+
-      if (response.success) {
+      if (response.changes == 1) {
         setOpen(true)
       }
 

src/renderer/src/components/AddMention.jsx

@@ -59,7 +59,7 @@ const AddMention = () => {
       try {
         let response = await window.mention.createMention(formData)
 
-        if (response.success) {
+        if (response.changes) {
           setOpen(true)
         }
       } catch (error) {

src/renderer/src/components/AddNiveau.jsx

@@ -107,7 +107,6 @@ const AddNiveau = () => {
 
     if (validation) {
       let response = await window.niveaus.insertNiveau(formData)
-
       let responses = JSON.parse(response)
       if (responses.changes == 1) {
         setOpen(true)
@@ -115,6 +114,10 @@ const AddNiveau = () => {
           nom: ''
         })
       }
+
+      if (response.code) {
+        nomError.current.textContent = `${formData.nom} existe déjà`
+      }
     }
   }
 

src/renderer/src/components/AddParcours.jsx

@@ -18,7 +18,7 @@ const AddParcours = ({ open, onClose, onSubmitSuccess }) => {
   const [formData, setFormData] = useState({
     nom: '',
     uniter: '',
-    mention_id: null
+    mention_id: ''
   })
 
   const [mention, setMention] = useState([])
@@ -37,14 +37,14 @@ const AddParcours = ({ open, onClose, onSubmitSuccess }) => {
   const handleSubmit = async (e) => {
     e.preventDefault()
     let response = await window.notesysteme.insertParcours(formData)
-    console.log(response) 
+
-    if (response.success) {
+    if (response.changes) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
       setFormData({
         nom: '',
         uniter: '',
-        mention_id: null
+        mention_id: ''
       })
     }
   }

src/renderer/src/components/AnneeScolaire.jsx

@@ -153,7 +153,7 @@ const AnneeScolaire = () => {
 
   const deleteButton = async (id) => {
     let response = await window.anneescolaire.deleteAnneeScolaire({ id })
-    if (response.success) {
+    if (response.changes) {
       const updatedAnneeScolaire = anneeScolaire.filter((anneeScolaire) => anneeScolaire.id !== id)
       setAnneeScolaire(updatedAnneeScolaire)
       setIsDeleted(true)

src/renderer/src/components/AssignMatiereToMention.jsx

@@ -50,7 +50,7 @@ const AssignMatiereToMention = () => {
 
     let response = await window.matieres.asign({ formData, id })
     console.log(response)
-    if (response.success) {
+    if (response.changes) {
       setOpen(true)
     }
   }

src/renderer/src/components/AssingMatiereToSemestre.jsx

@@ -73,7 +73,7 @@ const AssingMatiereToSemestre = () => {
     let response = await window.matieres.insertUpdateMentionSemestre({ id, selectedSemestres })
 
     console.log(response)
-    if (response.success) {
+    if (response.changes) {
       setOpen(true)
     }
   }

src/renderer/src/components/Login.jsx

@@ -1,4 +1,4 @@
-import { useRef, useState } from 'react'
+import React, { useRef, useState } from 'react'
 // import { Container, Row, Col, Form, Button, Card, InputGroup } from 'react-bootstrap';
 import { Container, Grid, Card, Typography, TextField, Button, InputAdornment } from '@mui/material'
 import { FaUserCircle, FaLock, FaUser } from 'react-icons/fa'
@@ -50,7 +50,7 @@ const Login = () => {
         // Redirect to main window
         setToken(JSON.stringify(response.user))
       } else {
-        invalidCredential(userNameError.current, response.error)
+        invalidCredential(userNameError.current)
       }
     }
   }

src/renderer/src/components/Matieres.jsx

@@ -260,7 +260,7 @@ const Matieres = () => {
 
   const deleteButton = async (id) => {
     let response = await window.matieres.deleteMatiere({ id })
-    if (response.success) {
+    if (response.changes) {
       const updatedMatieres = matiere.filter((matiere) => matiere.id !== id)
       setMatiere(updatedMatieres)
       setIsDeleted(true)

src/renderer/src/components/Mentions.jsx

@@ -106,7 +106,7 @@ const Mentions = () => {
 
   const deleteButton = async (id) => {
     let response = await window.mention.deleteMention({ id })
-    if (response.success) {
+    if (response.changes) {
       const updatedMentions = mentions.filter((mention) => mention.id !== id)
       setMentions(updatedMentions)
       setIsDeleted(true)

src/renderer/src/components/ModalAddProf.jsx

@@ -42,9 +42,8 @@ const ModalAddProf = ({ open, onClose, matiere_id, onSubmitSuccess }) => {
   const handleSubmit = async (e) => {
     e.preventDefault()
     let response = await window.matieres.insertProf(formData)
-    console.log(response)
 
-    if (response.success) {
+    if (response.changes) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
       setFormData({

src/renderer/src/components/Niveau.jsx

@@ -116,9 +116,7 @@ const Niveau = () => {
 
   const deleteButton = async (id) => {
     let response = await window.niveaus.deleteNiveaus({ id })
-    console.log(response);
+    if (response.changes) {
-
-    if (response.success) {
       const updatedNiveaus = niveaus.filter((niveau) => niveau.id !== id)
       setNiveau(updatedNiveaus)
       setIsDeleted(true)

src/renderer/src/components/ParcourMatiere.jsx

@@ -66,7 +66,7 @@ const ParcourMatiere = ({ open, onClose, matiere_id }) => {
   const formSubmit = async (e) => {
     e.preventDefault()
     let response = await window.notesysteme.parcourMatiere(formData)
-    if (response.success) {
+    if (response.changes) {
       onClose()
     }
   }

src/renderer/src/components/SingleAnneeScolaire.jsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react'
+import React, { useEffect, useRef, useState } from 'react'
 import classe from '../assets/AllStyleComponents.module.css'
 import classeHome from '../assets/Home.module.css'
 import Paper from '@mui/material/Paper'
@@ -9,7 +9,6 @@ import { FaCalendarAlt } from 'react-icons/fa'
 import svgError from '../assets/error.svg'
 import svgSuccess from '../assets/success.svg'
 import { BsCalendar2Date } from 'react-icons/bs'
-import dayjs from 'dayjs'
 
 const SingleAnneeScolaire = () => {
   const { id } = useParams()
@@ -34,8 +33,8 @@ const SingleAnneeScolaire = () => {
     setFormData((prev) => ({
       ...prev,
       code: scolaire.code,
-      debut: dayjs(scolaire.debut).format('YYYY-MM-DD'),
+      debut: scolaire.debut,
-      fin: dayjs(scolaire.fin).format('YYYY-MM-DD'),
+      fin: scolaire.fin,
       id: scolaire.id
     }))
   }, [scolaire])
@@ -57,7 +56,7 @@ const SingleAnneeScolaire = () => {
 
     let response = await window.anneescolaire.updateAnneeScolaire(formData)
 
-    if (response.success) {
+    if (response.changes) {
       setOpen(true)
       setStatus(200)
     } else {

src/renderer/src/components/SingleMatiere.jsx

@@ -80,10 +80,10 @@ const SingleMatiere = () => {
     e.preventDefault()
     const response = await window.matieres.updateMatiere(formData)
     console.log(response)
-    if (response.success) {
+    if (response.changes) {
       setStatus(200)
       setMessage('Modification a été effectuée avec succès')
-    } else {
+    } else if (response.code) {
       setStatus(400)
       setMessage('La matière existe déjà dans la base !')
     }

src/renderer/src/components/SingleNiveau.jsx

@@ -53,20 +53,19 @@ const SingleNiveau = () => {
     allNiveau.map((niv) => {
       niveauNom.push(niv.nom)
     })
-    // let validation = validationSingleNiveau(nomRef.current, errorRef.current, niveauNom)
+    let validation = validationSingleNiveau(nomRef.current, errorRef.current, niveauNom)
 
-    // if (validation) {
+    if (validation) {
-    let response = await window.niveaus.updateSingleNiveau(formData)
+      let response = await window.niveaus.updateSingleNiveau(formData)
-    console.log(response)
 
-    if (response.success) {
+      if (response.changes == 1) {
-      setOpen(true)
+        setOpen(true)
+      }
+
+      if (response.code) {
+        nomError.current.textContent = `${formData.nom} existe déjà`
+      }
     }
-
-    if (!response.success) {
-      errorRef.current.textContent = `${formData.nom} existe déjà`
-    }
-    // }
   }
 
   /**

src/renderer/src/components/SinleMention.jsx

@@ -81,7 +81,7 @@ const SinleMention = () => {
       try {
         let response = await window.mention.updateMention(formData)
 
-        if (response.success) {
+        if (response.changes) {
           setOpen(true)
         }
       } catch (error) {

src/renderer/src/components/UpdateModalProf.jsx

@@ -52,7 +52,7 @@ const UpdateModalProf = ({ open, onClose, matiere_id, onSubmitSuccess }) => {
     e.preventDefault()
     let response = await window.matieres.updateProf(formData)
 
-    if (response.success) {
+    if (response.changes) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
     }

src/renderer/src/components/UpdateParcour.jsx

@@ -59,7 +59,7 @@ const AddParcours = ({ open, onClose, onSubmitSuccess, id }) => {
     e.preventDefault()
     let response = await window.notesysteme.updateParcours(formData)
 
-    if (response.success) {
+    if (response.changes) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
     }

src/renderer/src/components/validation/Login.js

@@ -45,6 +45,6 @@ export const ValidationLogin = (userNameRef, password, userNameError, passwordEr
  *
  * @param {any} userNameError
  */
-export const invalidCredential = (userNameError, textC) => {
+export const invalidCredential = (userNameError) => {
-  userNameError.textContent = textC
+  userNameError.textContent = "Nom d'utilisateur ou Mot de passe incorrect"
 }