changement mysql a 80%

database/Models/AnneeScolaire.js

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

database/Models/Etudiants.backup.js

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

database/Models/IpConfig.js

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

database/Models/Matieres.backup.js

@@ -0,0 +1,354 @@
+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,6 +1,5 @@
-const { database } = require('../database')
+const { pool } = require('../database')
 const { matiereSysteme } = require('../function/System')
-const { convertArrayAndString } = require('../function/StringArrayConvertion')
 
 /**
  * function uset to create matiere
@@ -8,19 +7,22 @@ const { convertArrayAndString } = require('../function/StringArrayConvertion')
  * @returns Promise
  */
 async function createMatiere(nom, credit, uniter, ue) {
-  const query = database.prepare(
+  const sql =
     '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 {
-    response = await query.run(nom, uniter, credit, heure, ue)
+    const [result] = await pool.query(sql, [nom, uniter, credit, heure, ue])
 
-    return response
+    return {
+      success: true,
+      id: result.insertId
+    }
   } catch (error) {
-    return error
+    return { success: false, error: 'Erreur veullez réeseyer' + error }
   }
 }
 
@@ -29,14 +31,14 @@ async function createMatiere(nom, credit, uniter, ue) {
  * @returns Promise
  */
 async function getMatiere() {
-  const query = database.prepare('SELECT * FROM matieres ORDER BY id DESC')
+  const sql = 'SELECT * FROM matieres ORDER BY id DESC'
 
   try {
-    let response = await query.all()
+    let [rows] = await pool.query(sql)
 
-    return response
+    return rows
   } catch (error) {
-    return error
+    return { success: false, error: 'Erreur veullez réeseyer' + error }
   }
 }
 
@@ -51,7 +53,7 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
     }
 
     // Prepare the query
-    let matiereQuery = database.prepare(`
+    let matiereQuery = `
       SELECT DISTINCT m.*
       FROM matieres m
       JOIN matiere_semestre ms ON m.id = ms.matiere_id
@@ -61,17 +63,21 @@ 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 response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id, parcours)
+      let [rows] = await pool.query(matiereQuery, [
+        `%${semestre[0]}%`,
+        `%${semestre[1]}%`,
+        mention_id,
+        parcours
+      ])
 
-      console.log(response)
       // Log the response
-      return response
+      return rows
     } catch (error) {
-      return error
+      return { success: false, error: 'Erreur veullez réeseyer' + error }
     }
   } else {
     if (semestre.length < 2) {
@@ -80,23 +86,27 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
     }
 
     // Prepare the query
-    let matiereQuery = database.prepare(`
+    let matiereQuery = `
       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)
+      let [rows] = await pool.query(matiereQuery, [
-      console.log(response)
+        `%${semestre[0]}%`,
+        `%${semestre[1]}%`,
+        mention_id
+      ])
+
       // Log the response
-      return response
+      return rows
     } catch (error) {
-      return error
+      return { success: false, error: 'Erreur veullez réeseyer' + error }
     }
   }
 }
@@ -107,14 +117,14 @@ async function displayMatiereFromForm(niveau, mention_id, parcours) {
  * @returns promise
  */
 async function getSingleMatiere(id) {
-  const query = await database.prepare('SELECT * FROM matieres WHERE id = ?')
+  const sql = 'SELECT * FROM matieres WHERE id = ?'
 
   try {
-    let response = query.get(id)
+    let [rows] = await pool.query(sql, [id])
 
-    return response
+    return rows[0]
   } catch (error) {
-    return error
+    return { success: false, error: 'Erreur veullez réeseyer' + error }
   }
 }
 
@@ -125,211 +135,325 @@ async function getSingleMatiere(id) {
  * @returns promise
  */
 async function updateMatiere(nom, id, credit, uniter, ue) {
-  const query = database.prepare(
+  const sql =
     'UPDATE matieres SET nom = ?, credit = ?, unite_enseignement = ?, heure = ?, ue = ? WHERE id = ?'
-  )
 
-  const uniterHeure = await database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
+  const uniterHeure = 'SELECT uniter_heure FROM nessesaryTable'
-  const heure = credit * uniterHeure.uniter_heure
+  let [rows] = await pool.query(uniterHeure)
+  const uniterHeureValue = rows[0].uniter_heure
+  const heure = credit * uniterHeureValue
 
   try {
-    response = await query.run(nom, credit, uniter, heure, ue, id)
+    let [result] = await pool.query(sql, [nom, credit, uniter, heure, ue, id])
 
-    return response
+    if (result.affectedRows === 0) {
+      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
+    return { success: false, error: 'Erreur veullez réeseyer' + error }
   }
 }
 
 async function deleteMatiere(id) {
-  const query = database.prepare('DELETE FROM matieres WHERE id = ?')
+  const sql = 'DELETE FROM matieres WHERE id = ?'
 
   try {
-    let response = query.run(id)
+    let [result] = await pool.query(sql, [id])
 
-    return response
+    if (result.affectedRows === 0) {
+      return {
+        success: false,
+        message: 'Année universitaire non trouvé.'
+      }
+    }
+
+    return {
+      success: true,
+      message: 'Année universitaire supprimé avec succès.'
+    }
   } catch (error) {
-    return error
+    return { success: false, error: 'Erreur veullez réeseyer' + 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 clearNoreQuery = database.prepare(
+  const deleteMentionSql = `
-    `DELETE FROM notes WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
+    DELETE FROM matiere_mention
-  )
+    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 {
-    let response
+    const connection = await pool.getConnection()
-    await clearQuery.run(id)
+    try {
-    await clearNoreQuery.run(id, ...selectedKeys)
+      await connection.beginTransaction()
-    clearSemestreMentionQuery.run(id, ...selectedKeys)
+
-    // use transaction for speed execution
+      // delete all from matiere_mention for this matiere
-    database.transaction(() => {
+      await connection.query(deleteMentionSql, [id])
-      for (let index = 0; index < selectedKeys.length; index++) {
+
-        response = query.run(id, selectedKeys[index])
+      // delete from matiere_semestre not in selected mentions
+      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])
       }
-    })()
 
-    return response
+      await connection.commit()
-  } catch (error) {
+
-    return error
+      return { success: true }
+    } 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 query = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
+  const sql = 'SELECT * FROM matiere_mention WHERE matiere_id = ?'
 
   try {
-    let response = await query.all(id)
+    let [rows] = await pool.query(sql, [id])
 
-    return response
+    return rows
   } catch (error) {
     return error
   }
 }
 
 async function getMentionMatiereChecked(matiere_id) {
-  const getMentionMatiere = database.prepare('SELECT * FROM matiere_mention WHERE matiere_id = ?')
+  const getMentionMatiere = 'SELECT * FROM matiere_mention WHERE matiere_id = ?'
-  let MentionArray = await getMentionMatiere.all(matiere_id)
+  let [rows] = await pool.query(getMentionMatiere, [matiere_id])
+  let MentionArray = rows
   let arrayID = []
 
   for (let index = 0; index < MentionArray.length; index++) {
     arrayID.push(MentionArray[index].mention_id)
   }
 
-  const mentionQuery = database.prepare(
+  const mentionQuery = `SELECT * FROM mentions WHERE id IN (${arrayID.map(() => '?').join(', ')})`
-    `SELECT * FROM mentions WHERE id IN (${arrayID.map(() => '?').join(', ')})`
-  )
 
   try {
-    const results = await mentionQuery.all(...arrayID)
+    let [rows] = await pool.query(mentionQuery, [...arrayID])
 
-    return results
+    return rows
   } catch (error) {
     return error
   }
 }
 
 async function getSemestreMatiere(id) {
-  const query = database.prepare('SELECT * FROM matiere_semestre WHERE matiere_id = ?')
+  const sql = 'SELECT * FROM matiere_semestre WHERE matiere_id = ?'
 
   try {
-    let response = await query.all(id)
+    let [rows] = await pool.query(sql, [id])
 
-    return response
+    return rows
   } catch (error) {
     return error
   }
 }
 
 async function getSemestre() {
-  const query = database.prepare('SELECT * FROM semestres')
+  const sql = 'SELECT * FROM semestres'
 
   try {
-    let response = await query.all()
+    let [rows] = await pool.query(sql)
 
-    return response
+    return rows
   } catch (error) {
     return error
   }
 }
 
 async function insertUpdateMentionSemestre(matiere_id, formData) {
-  const clearQuery = database.prepare('DELETE FROM matiere_semestre WHERE matiere_id = ?')
+  try {
-  clearQuery.run(matiere_id)
+    const connection = await pool.getConnection()
-
+
-  const query = database.prepare(
+    try {
-    'INSERT INTO matiere_semestre (matiere_id, semestre_id, mention_id) VALUES (?, ?, ?)'
+      await connection.beginTransaction()
-  )
+
-  let response
+      // Clear all old rows
-  database.transaction(() => {
+      const deleteSql = `
-    for (const key in formData) {
+        DELETE FROM matiere_semestre
-      if (formData.hasOwnProperty(key)) {
+        WHERE matiere_id = ?
-        for (let jindex = 0; jindex < formData[key].length; jindex++) {
+      `
-          response = query.run(matiere_id, formData[key][jindex], key)
+      await connection.query(deleteSql, [matiere_id])
+
+      // 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) {
-  return response
+    console.error(err)
+    return { success: false, error: 'Database connection failed.' }
+  }
 }
 
 async function getEnseignants() {
-  const getIdQuery = database.prepare(
+  try {
-    'SELECT id FROM matiereEnseignants GROUP BY matiere_id ORDER BY MAX(date) DESC'
+    const latestIdsSql = `
-  )
+      SELECT MAX(id) AS id
+      FROM matiereEnseignants
+      GROUP BY matiere_id
+      ORDER BY MAX(date) DESC
+    `
 
-  const query = database.prepare(
+    const [rows] = await pool.query(latestIdsSql)
-    'SELECT * FROM matiereEnseignants WHERE id IN (' +
-      new Array(getIdQuery.all().length).fill('?').join(',') +
-      ')'
-  )
 
-  try {
+    const latestIds = rows.map((r) => r.id)
-    // 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
+    // Build placeholders (?, ?, ?, …)
-    let response = query.all(...latestIds)
+    const placeholders = latestIds.map(() => `?`).join(`,`)
+    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 query = database.prepare(
+  const sql = `
-    'INSERT INTO matiereEnseignants (matiere_id, nom_enseignant, prenom_enseignant, contact, date) VALUES (?, ?, ?, ?, ?)'
+    INSERT INTO matiereEnseignants
-  )
+      (matiere_id, nom_enseignant, prenom_enseignant, contact, date)
+    VALUES (?, ?, ?, ?, ?)
+  `
 
   try {
-    let response = query.run(matiere_id, nom, prenom, contact, date)
+    const [result] = await pool.query(sql, [matiere_id, nom, prenom, contact, date])
 
-    return response
+    return {
+      success: true,
+      id: result.insertId
+    }
   } catch (error) {
+    console.error(error)
     return error
   }
 }
 
-async function getSIngleProf(id) {
+async function getSIngleProf(matiere_id) {
-  try {
+  const sql = `
-    const prof = await database
+    SELECT *
-      .prepare('SELECT * FROM matiereEnseignants WHERE matiere_id = ?')
+    FROM matiereEnseignants
-      .get(id)
+    WHERE matiere_id = ?
+    ORDER BY date DESC
+    LIMIT 1
+  `
 
-    return prof
+  try {
+    const [rows] = await pool.query(sql, [matiere_id])
+    return rows[0] || null
   } catch (error) {
+    console.error(error)
     return error
   }
 }
 
 async function updateProf(matiere_id, nom, prenom, contact, date) {
-  const query = database.prepare(
+  const sql = `
-    'UPDATE matiereEnseignants SET nom_enseignant = ?, prenom_enseignant = ?, contact = ?, date = ? WHERE matiere_id = ?'
+    UPDATE matiereEnseignants
-  )
+    SET nom_enseignant = ?,
+        prenom_enseignant = ?,
+        contact = ?,
+        date = ?
+    WHERE matiere_id = ?
+  `
 
   try {
-    let response = query.run(nom, prenom, contact, date, matiere_id)
+    const [result] = await pool.query(sql, [nom, prenom, contact, date, matiere_id])
+
+    if (result.affectedRows === 0) {
+      return {
+        success: false,
+        message: 'Année universitaire non trouvé.'
+      }
+    }
 
-    return response
+    return {
+      success: true,
+      message: 'Année universitaire supprimé avec succès.'
+    }
   } catch (error) {
+    console.error(error)
     return error
   }
 }

database/Models/Mentions.js

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

database/Models/Niveau.js

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

database/Models/NoteRepechage.js

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

database/Models/NoteSysrem.js

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

database/Models/Notes.js

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

database/Models/Parcours.js

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

database/Models/Status.js

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

database/Models/Users.js

@@ -72,7 +72,7 @@ async function loginUsers(username, password) {
   const sql = `SELECT * FROM users WHERE LOWER(username) = ?`
 
   try {
-    const [rows] = pool.query(sql, username)
+    const [rows] = await pool.query(sql, [username.toLowerCase()])
 
     if (rows.length === 0) {
       return { success: false, error: 'Utilisateur inexistant' }

database/database.js

@@ -52,7 +52,7 @@ async function createTables() {
     await connection.query(`
       CREATE TABLE IF NOT EXISTS niveaus (
         id INT AUTO_INCREMENT PRIMARY KEY,
-        nom VARCHAR(50) NOT NULL,
+        nom VARCHAR(50) UNIQUE NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
       ) ENGINE=InnoDB;
@@ -69,7 +69,7 @@ async function createTables() {
         annee_scolaire VARCHAR(20) NOT NULL,
         status INT DEFAULT NULL,
         mention_id INT NOT NULL,
-        num_inscription TEXT NOT NULL,
+        num_inscription TEXT UNIQUE NOT NULL,
         sexe VARCHAR(20) DEFAULT NULL,
         cin VARCHAR(250) DEFAULT NULL,
         date_delivrance DATE DEFAULT NULL,

database/function/System.js

@@ -1,261 +1,261 @@
-const { database } = require('../database')
+const { pool } = require('../database')
 const dayjs = require('dayjs')
 
 async function updateCurrentYears() {
   const fullDate = dayjs().format('YYYY-MM-DD')
 
   // Clear current year flag
-  const clearCurrent = database.prepare('UPDATE anneescolaire SET is_Current = 0 WHERE id > 0')
+  const clearCurrent = 'UPDATE anneescolaire SET is_Current = 0 WHERE id > 0'
-  clearCurrent.run()
+  pool.query(clearCurrent)
 
   // Set the new current year
-  const updateCurrent = database.prepare(`
+  const updateCurrent = `
     UPDATE anneescolaire
     SET is_Current = 1
     WHERE ? >= debut AND ? <= fin
-  `)
+  `
   // console.log();
-  updateCurrent.run(fullDate, fullDate)
+  pool.query(updateCurrent, [fullDate, fullDate])
 
   // Check if the update was successful
-  const check = database
+  const sql = `
-    .prepare(
+      SELECT * FROM anneescolaire
-      `
+      WHERE ? >= debut AND ? <= fin
-    SELECT * FROM anneescolaire
+    `
-    WHERE ? >= debut AND ? <= fin
+  const [rows] = await pool.query(sql, [fullDate, fullDate])
-  `
+
-    )
+  const check = rows[0]
-    .get(fullDate, fullDate)
+  if (!check) return
-
+
-  // Insert into traitmentsystem if a current year exists
+  // 2. Check if already in traitmentsystem
-  if (check) {
+  const searchSql = `SELECT * FROM traitmentsystem WHERE code = ?`
-    let search = database.prepare('SELECT * FROM traitmentsystem WHERE code = ?').get(check.code)
+  const [searchRows] = await pool.query(searchSql, [check.code])
-    console.log(search)
+
-    if (!search) {
+  if (searchRows.length === 0) {
-      const insertQuery = database.prepare(`
+    // 3. Insert into traitmentsystem
+    const insertSql = `
         INSERT INTO traitmentsystem (code, debut, fin)
         VALUES (?, ?, ?)
-      `)
+      `
-      insertQuery.run(check.code, check.debut, check.fin)
+    await pool.query(insertSql, [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')
+const { database } = require('../database.backup')
 
 /**
  * Function to import data from the first column of an XLSX or CSV file into SQLite database

package.json

@@ -10,6 +10,7 @@
     "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",
@@ -76,6 +77,7 @@
     "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/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.changes) {
+      if (response.success) {
         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.changes == 1) {
+      if (response.success) {
         setOpen(true)
       }
 

src/renderer/src/components/AddMention.jsx

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

src/renderer/src/components/AddNiveau.jsx

@@ -107,6 +107,7 @@ const AddNiveau = () => {
 
     if (validation) {
       let response = await window.niveaus.insertNiveau(formData)
+
       let responses = JSON.parse(response)
       if (responses.changes == 1) {
         setOpen(true)
@@ -114,10 +115,6 @@ 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: ''
+    mention_id: null
   })
 
   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.changes) {
+    if (response.success) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
       setFormData({
         nom: '',
         uniter: '',
-        mention_id: ''
+        mention_id: null
       })
     }
   }

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.changes) {
+    if (response.success) {
       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.changes) {
+    if (response.success) {
       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.changes) {
+    if (response.success) {
       setOpen(true)
     }
   }

src/renderer/src/components/Login.jsx

@@ -1,4 +1,4 @@
-import React, { useRef, useState } from 'react'
+import { 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)
+        invalidCredential(userNameError.current, response.error)
       }
     }
   }

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.changes) {
+    if (response.success) {
       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.changes) {
+    if (response.success) {
       const updatedMentions = mentions.filter((mention) => mention.id !== id)
       setMentions(updatedMentions)
       setIsDeleted(true)

src/renderer/src/components/ModalAddProf.jsx

@@ -42,8 +42,9 @@ 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.changes) {
+    
+    if (response.success) {
       onSubmitSuccess(true)
       onClose() // Close the modal after submission
       setFormData({

src/renderer/src/components/Niveau.jsx

@@ -116,7 +116,9 @@ const Niveau = () => {
 
   const deleteButton = async (id) => {
     let response = await window.niveaus.deleteNiveaus({ id })
-    if (response.changes) {
+    console.log(response);
+
+    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.changes) {
+    if (response.success) {
       onClose()
     }
   }

src/renderer/src/components/SingleAnneeScolaire.jsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useRef, useState } from 'react'
+import { useEffect, useState } from 'react'
 import classe from '../assets/AllStyleComponents.module.css'
 import classeHome from '../assets/Home.module.css'
 import Paper from '@mui/material/Paper'
@@ -9,6 +9,7 @@ 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()
@@ -33,8 +34,8 @@ const SingleAnneeScolaire = () => {
     setFormData((prev) => ({
       ...prev,
       code: scolaire.code,
-      debut: scolaire.debut,
+      debut: dayjs(scolaire.debut).format('YYYY-MM-DD'),
-      fin: scolaire.fin,
+      fin: dayjs(scolaire.fin).format('YYYY-MM-DD'),
       id: scolaire.id
     }))
   }, [scolaire])
@@ -56,7 +57,7 @@ const SingleAnneeScolaire = () => {
 
     let response = await window.anneescolaire.updateAnneeScolaire(formData)
 
-    if (response.changes) {
+    if (response.success) {
       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.changes) {
+    if (response.success) {
       setStatus(200)
       setMessage('Modification a été effectuée avec succès')
-    } else if (response.code) {
+    } else {
       setStatus(400)
       setMessage('La matière existe déjà dans la base !')
     }

src/renderer/src/components/SingleNiveau.jsx

@@ -53,19 +53,20 @@ 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.changes == 1) {
+    if (response.success) {
-        setOpen(true)
+      setOpen(true)
-      }
+    }
 
-      if (response.code) {
+    if (!response.success) {
-        nomError.current.textContent = `${formData.nom} existe déjà`
+      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.changes) {
+        if (response.success) {
           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.changes) {
+    if (response.success) {
       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.changes) {
+    if (response.success) {
       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) => {
+export const invalidCredential = (userNameError, textC) => {
-  userNameError.textContent = "Nom d'utilisateur ou Mot de passe incorrect"
+  userNameError.textContent = textC
 }