stephane/C-university
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: stephane:0cf0a728141ed3177a33814042ad438383553fba
Branches Tags
stephane:master
..
compare: stephane:82b5e6a68e2d18ff280aa05ba60dddb973be6f18
Branches Tags
stephane:master

No commits in common. "0cf0a728141ed3177a33814042ad438383553fba" and "82b5e6a68e2d18ff280aa05ba60dddb973be6f18" have entirely different histories.
0cf0a72814 ... 82b5e6a68e

47 changed files with 1285 additions and 3869 deletions
Show Stats Expand all files Collapse all files

95
database/Models/AnneeScolaire.js
View File

@ -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 {
success: true,
id: result.insertId
}
return response
} 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 {
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.'
}
return response
} 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 sql2 = 'UPDATE anneescolaire SET is_current = 1 WHERE id = ?'
pool.query(sql)
const query = database.prepare(
'UPDATE anneescolaire SET is_current = 0 WHERE id > 0 AND is_current = 1'
)
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])
console.log(result)
let response = query2.run(id)
return {
success: true,
id: result.insertId
}
return response
} catch (error) {
return { success: false, error: 'Erreur veullez réeseyer' }
return error
}
}

305
database/Models/Etudiants.backup.js
View File

@ -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
}

116
database/Models/Etudiants.js
View File

@ -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 {
success: true,
id: result.insertId
}
)
return response
} 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} catch (error) {
return error
}
@ -195,17 +189,14 @@ async function updateEtudiant(
* @returns promise
*/
async function getDataToDashboard() {
const query = 'SELECT * FROM niveaus'
const query2 = 'SELECT * FROM etudiants'
const query3 = 'SELECT DISTINCT annee_scolaire FROM etudiants' // get all année scolaire sans doublan
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 [rows] = await pool.query(query)
let niveau = rows
;[rows] = await pool.query(query2)
let etudiants = rows
;[rows] = await pool.query(query3)
let anne_scolaire = rows
let niveau = query.all()
let etudiants = query2.all()
let anne_scolaire = query3.all()
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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 {
success: true,
id: result.insertId
}
return response
} catch (error) {
return error
}

2
database/Models/IpConfig.js
View File

@ -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 (?)');

354
database/Models/Matieres.backup.js
View File

@ -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
}

372
database/Models/Matieres.js
View File

@ -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 {
success: true,
id: result.insertId
}
return response
} 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, [
`%${semestre[0]}%`,
`%${semestre[1]}%`,
mention_id,
parcours
])
let response = matiereQuery.all(`%${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, [
`%${semestre[0]}%`,
`%${semestre[1]}%`,
mention_id
])
let response = matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id)
console.log(response)
// 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'
let [rows] = await pool.query(uniterHeure)
const uniterHeureValue = rows[0].uniter_heure
const heure = credit * uniterHeureValue
const uniterHeure = await database.prepare('SELECT uniter_heure FROM nessesaryTable').get()
const heure = credit * uniterHeure.uniter_heure
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 {
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.'
}
return response
} 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 = `
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 (?, ?)
`
const clearNoreQuery = database.prepare(
`DELETE FROM notes WHERE matiere_id = ? AND mention_id NOT IN (${placeholders})`
)
try {
const connection = await pool.getConnection()
try {
await connection.beginTransaction()
// delete all from matiere_mention for this matiere
await connection.query(deleteMentionSql, [id])
// 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])
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])
}
})()
await connection.commit()
return { success: true }
return response
} 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.' }
return 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 = ?'
let [rows] = await pool.query(getMentionMatiere, [matiere_id])
let MentionArray = rows
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 = `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 connection = await pool.getConnection()
const clearQuery = database.prepare('DELETE FROM matiere_semestre WHERE matiere_id = ?')
clearQuery.run(matiere_id)
try {
await connection.beginTransaction()
// Clear all old rows
const deleteSql = `
DELETE FROM matiere_semestre
WHERE matiere_id = ?
`
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])
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)
}
}
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 { success: false, error: 'Database connection failed.' }
}
})()
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 {
const latestIdsSql = `
SELECT MAX(id) AS 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)
// 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 []
}
// Build placeholders (?, ?, ?, …)
const placeholders = latestIds.map(() => `?`).join(`,`)
const fetchSql = `
SELECT *
FROM matiereEnseignants
WHERE id IN (${placeholders})
`
// Fetch the full details using the filtered IDs
let response = query.all(...latestIds)
const [enseignants] = await pool.query(fetchSql, latestIds)
return enseignants
return response
} catch (error) {
console.error(error)
return error
}
}
async function insertNewProf(matiere_id, nom, prenom, contact, date) {
const sql = `
INSERT INTO matiereEnseignants
(matiere_id, nom_enseignant, prenom_enseignant, contact, date)
VALUES (?, ?, ?, ?, ?)
`
const query = database.prepare(
'INSERT INTO matiereEnseignants (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 {
success: true,
id: result.insertId
}
return response
} catch (error) {
console.error(error)
return error
}
}
async function getSIngleProf(matiere_id) {
const sql = `
SELECT *
FROM matiereEnseignants
WHERE matiere_id = ?
ORDER BY date DESC
LIMIT 1
`
async function getSIngleProf(id) {
try {
const [rows] = await pool.query(sql, [matiere_id])
return rows[0] || null
const prof = await database
.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 = `
UPDATE matiereEnseignants
SET nom_enseignant = ?,
prenom_enseignant = ?,
contact = ?,
date = ?
WHERE matiere_id = ?
`
const query = database.prepare(
'UPDATE matiereEnseignants 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} catch (error) {
console.error(error)
return error
}
}

65
database/Models/Mentions.js
View File

@ -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 {
success: true,
id: result.insertId
}
return response
} 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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 {
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.'
}
return response
} catch (error) {
return { success: false, error: 'Erreur veullez réeseyer' + error }
return error
}
}

70
database/Models/Niveau.js
View File

@ -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])
responses.push(result)
let response = await query.run(name)
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 rows[0]
} else {
return null
}
return response
} 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 {
success: false,
message: 'Niveau non trouvé ou aucune modification effectuée.'
}
}
return {
success: true,
message: 'Utilisateur mis à jour avec succès.'
}
return response
} 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 {
success: false,
message: 'Niveau non trouvé.'
}
}
return {
success: true,
message: 'Niveau supprimé avec succès.'
}
return response
} catch (error) {
return {
success: false,
error: 'Erreur lors de la suppression, veuillez réessayer.'
}
return error
}
}

2
database/Models/NoteRepechage.js
View File

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

2
database/Models/NoteSysrem.js
View File

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

2
database/Models/Notes.js
View File

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

192
database/Models/Parcours.js
View File

@ -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 {
success: true,
id: result.insertId
}
return response
} 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])
return rows
let response
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 {
success: false,
message: 'Année universitaire non trouvé.'
}
}
return {
success: true,
message: 'Année universitaire supprimé avec succès.'
}
return response
} 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 {
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.'
}
return response
} 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
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' }
let response
database.transaction(() => {
for (let index = 0; index < parcour_id.length; index++) {
response = query.run(matiere_id, parcour_id[index])
}
})()
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 }
return response
} catch (error) {
console.error(error)
return { success: false, error: error.message }
return error
}
}
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()
// 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 matiereSemestre = query.all(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)
}
// Remove duplicates
let newResponse = []
for (let index = 0; index < response.length; index++) {
if (response[index] !== response[index + 1]) {
if (response[index] != response[index + 1]) {
newResponse.push(response[index])
}
}
// Get all students for the matched niveau and school year
let allStudents = []
for (let index = 0; index < newResponse.length; index++) {
const [students] = await connection.query(
`
SELECT * FROM etudiants
WHERE niveau LIKE ? AND annee_scolaire LIKE ?
`,
[`%${newResponse[index]}%`, `%${now}%`]
)
allStudents.push(...students)
allSTudent = allStudentQuery.all(`%${newResponse[index]}%`, `%${now}%`)
}
// Filter students by mention
const studentFiltredMention = allStudents.filter((etudiant) =>
allMention_id.includes(etudiant.mention_id)
)
// Filter by parcours
let studentFiltredMention = []
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 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)
if (parcours[j].parcour_id == 1) {
if (
studentFiltredMention[index].parcours == null ||
studentFiltredMention[index].parcours == parcours[j].nom
) {
allData.push(studentFiltredMention[index])
}
} else {
if (currentStudent.parcours == parcoursName) {
allData.push(currentStudent)
if (studentFiltredMention[index].parcours == parcours[j].nom) {
allData.push(studentFiltredMention[index])
}
}
}
}
await connection.commit()
connection.release()
return allData
})()
return realSponse
} catch (error) {
await connection.rollback()
connection.release()
console.error(error)
return { success: false, error: error.message }
return error
}
}

2
database/Models/Status.js
View File

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

149
database/Models/Users.backup.js
View File

@ -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
}

256
database/Models/Users.js
View File

@ -1,177 +1,149 @@
const { pool } = require('../database')
const { database } = require('../database')
const bcrypt = require('bcryptjs')
/**
* function to insert new user
* @param {String} username
* @param {String} email
* @param {String} password
* @param {String} roles
* @returns {Object}
*/
// Function to insert a user into the database
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 = `
INSERT INTO users (username, email, password, roles) VALUES (?, ?, ?, ?)
`
const [result] = await pool.query(sql, [username, email, hashedPassword, roles])
// 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)
// result.insertId contains the new user ID
return {
success: true,
id: result.insertId
}
} catch (error) {
return { success: false, error: error }
return insertedUser
} catch (err) {
return err
}
}
/**
* function to get all users
* @returns {Array}
*/
// Function to fetch all users from the database
async function getAllUsers() {
const sql = `SELECT * FROM users`
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 {
const [rows] = await pool.query(sql)
// Execute the query and get the user from the database
const user = await loginUserQuery.get(username.toLowerCase())
return rows
} catch (error) {
return 'failled to get users'
}
}
if (user) {
// Use bcrypt to compare the provided password with the stored hashed password
const isPasswordValid = await bcrypt.compare(password, user.password)
/**
* function to get one users
* @param {Number} id
* @returns {Object}
*/
async function getUserById(id) {
const sql = `SELECT * FROM users WHERE id = ?`
const [rows] = await pool.query(sql, [id])
if (rows.length > 0) {
return rows[0]
if (isPasswordValid) {
// If password matches, return the user
return user
} else {
return null
// If password does not match
console.log('Invalid password')
}
}
/**
* 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()])
if (rows.length === 0) {
return { success: false, error: 'Utilisateur inexistant' }
}
const user = rows[0]
// compare the password
const passwordMatch = await bcrypt.compare(password, user.password)
if (!passwordMatch) {
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]
// If no user is found with the provided username
console.log('User not found')
}
try {
const [result] = await pool.query(sql, params)
if (result.affectedRows === 0) {
return {
success: false,
message: 'Utilisateur 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' }
} catch (err) {
console.error('Error during login:', err)
}
}
/**
* function to delete users
* @param {Number} id
* @returns {Object}
* function to use in forgit password
*
* @param {*} email
* @param {*} password
* @param {*} passwordConfirmation
* @returns
*/
async function deleteUser(id) {
const sql = `DELETE FROM users WHERE id = ?`
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 {
const [result] = await pool.query(sql, [id])
await updateQuery.run(hashedPassword, email)
if (result.affectedRows === 0) {
return {
success: false,
message: 'Utilisateur non trouvé.'
}
}
return {
success: true,
message: 'Utilisateur supprimé avec succès.'
}
return { message: 'Mot de passe modifier avec succes', status: 200 }
} catch (error) {
console.error(error)
return {
success: false,
error: 'Erreur lors de la suppression, veuillez réessayer.'
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 = {
insertUser,
getAllUsers,
getUserById,
loginUsers,
updateUser,
deleteUser
insertUser,
loginUser,
forgotPassword,
updateUser
}

444
database/database.backup.js
View File

@ -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
}

499
database/database.js
View File

@ -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() {
const connection = await pool.getConnection()
// Construct the database path using the detected IP
let dbPath = `./base/data.db`;
try {
// Users table
await connection.query(`
// 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 INT AUTO_INCREMENT PRIMARY KEY,
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 ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createUserTableQuery).run()
// Status table
await connection.query(`
// 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 INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
nom VARCHAR(200) NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createStatusTableQuery).run()
// Mentions table
await connection.query(`
// create table for mention
const createMentionTableQuery = `
CREATE TABLE IF NOT EXISTS mentions (
id INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
nom VARCHAR(250) NOT NULL,
uniter VARCHAR(50) NOT NULL,
uniter VARCHAR(50) NOT NULL, -- Abréviation du nom
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createMentionTableQuery).run()
await connection.query(`
// Create the niveau table if it doesn't exist
const createNiveauTableQuery = `
CREATE TABLE IF NOT EXISTS niveaus (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) UNIQUE NOT NULL,
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 ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createNiveauTableQuery).run()
await connection.query(`
// Create the etudiants table if it doesn't exist
const createEtudiantsTableQuery = `
CREATE TABLE IF NOT EXISTS etudiants (
id INT AUTO_INCREMENT PRIMARY KEY,
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,
niveau VARCHAR(250) NOT NULL, -- Clé étrangère vers niveaus
annee_scolaire VARCHAR(20) NOT NULL,
status INT DEFAULT NULL,
mention_id INT NOT NULL,
num_inscription TEXT UNIQUE 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 DATE DEFAULT NULL,
date_delivrance DEFAULT NULL,
nationalite DATE DEFAULT NULL,
annee_bacc DATE DEFAULT NULL,
serie VARCHAR(20) DEFAULT NULL,
boursier TINYINT(1) DEFAULT 0,
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 ON UPDATE CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (status) REFERENCES status(id),
FOREIGN KEY (mention_id) REFERENCES mentions(id)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createEtudiantsTableQuery).run()
await connection.query(`
// Create the notes table if it doesn't exist
const createMatiereTableQuery = `
CREATE TABLE IF NOT EXISTS matieres (
id INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
nom VARCHAR(250) UNIQUE NOT NULL,
unite_enseignement VARCHAR(250) NOT NULL,
credit INT NOT NULL,
heure INT 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 ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createMatiereTableQuery).run()
await connection.query(`
// Create the semestre table if it doesn't exist
const createSemestreTableQuery = `
CREATE TABLE IF NOT EXISTS semestres (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(30) NOT NULL,
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 ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createSemestreTableQuery).run()
await connection.query(`
// Create the semestre table if it doesn't exist
const createMatiere_mentionTableQuery = `
CREATE TABLE IF NOT EXISTS matiere_mention (
id INT AUTO_INCREMENT PRIMARY KEY,
matiere_id INT NOT NULL,
mention_id INT NOT NULL,
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)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createMatiere_mentionTableQuery).run()
await connection.query(`
const createMatiere_semestreTableQuery = `
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,
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)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createMatiere_semestreTableQuery).run()
await connection.query(`
// Create the notes table if it doesn't exist
const createNoteTableQuery = `
CREATE TABLE IF NOT EXISTS notes (
id INT AUTO_INCREMENT PRIMARY KEY,
etudiant_id INT NOT NULL,
matiere_id INT NOT NULL,
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 INT 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 ON UPDATE CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
FOREIGN KEY (matiere_id) REFERENCES matieres(id),
FOREIGN KEY (matiere_id) REFERENCES matieres(id)
FOREIGN KEY (mention_id) REFERENCES mentions(id)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createNoteTableQuery).run()
await connection.query(`
// Create the notes second session table if it doesn't exist
const createNoteRepechTableQuery = `
CREATE TABLE IF NOT EXISTS notesrepech (
id INT AUTO_INCREMENT PRIMARY KEY,
etudiant_id INT NOT NULL,
matiere_id INT NOT NULL,
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 INT 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 ON UPDATE CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (etudiant_id) REFERENCES etudiants(id),
FOREIGN KEY (matiere_id) REFERENCES matieres(id),
FOREIGN KEY (matiere_id) REFERENCES matieres(id)
FOREIGN KEY (mention_id) REFERENCES mentions(id)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createNoteRepechTableQuery).run()
await connection.query(`
// create table for note système
const createNoteSystemeTableQuery = `
CREATE TABLE IF NOT EXISTS notesystems (
id INT AUTO_INCREMENT PRIMARY KEY,
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 ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createNoteSystemeTableQuery).run()
await connection.query(`
// create table année scolaire
const createAnneeScolaireTableQuery = `
CREATE TABLE IF NOT EXISTS anneescolaire (
id INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
code VARCHAR(30) NOT NULL,
debut DATE NOT NULL,
fin DATE NOT NULL,
is_current TINYINT(1) DEFAULT 0,
is_current INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createAnneeScolaireTableQuery).run()
await connection.query(`
// create traitement systeme
const createTraitementSystemQuery = `
CREATE TABLE IF NOT EXISTS traitmentsystem (
id INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
code VARCHAR(30) NOT NULL,
debut DATE NOT NULL,
fin DATE NOT NULL,
is_finished TINYINT(1) DEFAULT 0,
is_finished INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createTraitementSystemQuery).run()
await connection.query(`
const createNecessaryParameterTableQuery = `
CREATE TABLE IF NOT EXISTS nessesaryTable (
id INT AUTO_INCREMENT PRIMARY KEY,
uniter_heure INT NOT NULL,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
uniter_heure INTEGER NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createNecessaryParameterTableQuery).run()
await connection.query(`
const createMatiereEnseignantTableQuery = `
CREATE TABLE IF NOT EXISTS matiereEnseignants (
id INT AUTO_INCREMENT PRIMARY KEY,
matiere_id INT NOT NULL,
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 ON UPDATE CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (matiere_id) REFERENCES matieres(id)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createMatiereEnseignantTableQuery).run()
await connection.query(`
const createParcourTableQuery = `
CREATE TABLE IF NOT EXISTS parcours (
id INT AUTO_INCREMENT PRIMARY KEY,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
nom VARCHAR(250) NOT NULL,
uniter VARCHAR(250) NOT NULL,
mention_id INT DEFAULT NULL,
mention_id INTEGER DEFAULT NULL, -- Clé étrangère vers mentions
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
`)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`
database.prepare(createParcourTableQuery).run()
await connection.query(`
const createParcourSemestreTableQuery = `
CREATE TABLE IF NOT EXISTS parcoursmatiere (
id INT AUTO_INCREMENT PRIMARY KEY,
matiere_id INT NOT NULL,
parcour_id INT NOT NULL,
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)
) ENGINE=InnoDB;
`)
);
`
database.prepare(createParcourSemestreTableQuery).run()
await connection.query(`
const createTableEcolageQuery = `
CREATE TABLE IF NOT EXISTS trancheecolage (
id INT AUTO_INCREMENT PRIMARY KEY,
etudiant_id INT NOT NULL,
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
etudiant_id INTEGER 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()
}
}
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
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 {
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])
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)
}
}
} finally {
conn.release()
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,
createTables,
insertDefaultAdmin,
insertStatusesIfNotExist
database
}

307
database/database2.js
View File

@ -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
}

452
database/function/System.js
View File

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

2
database/import/Matieres.js
View File

@ -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

15
jsconfig.json
View File

@ -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/*"
]
}

4
package.json
View File

@ -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",

799
src/main/backup.js
View File

@ -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
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')
import icon from '../../resources/icon.png?asset'
const { loginUser, forgotPassword, insertUser, updateUser } = require('../../database/Models/Users')
const {
insertEtudiant,
getSingleEtudiant,
FilterDataByNiveau,
updateEtudiant,
changePDP,
updateParcours,
createTranche,
getTranche,
updateTranche,
deleteTranche,
getSingleTranche
updateEtudiant
} = require('../../database/Models/Etudiants')
const {
insertNiveau,
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')
const { insertNiveau } = require('../../database/Models/Niveau')
const { insertNote } = require('../../database/Models/Notes')
// 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,
minWidth: 1375,
height: 740,
minHeight: 740,
width: 1000,
minWidth: 1000,
height: 670,
minHeight: 670,
show: false,
autoHideMenuBar: true,
fullscreen: false,
icon: path.join(__dirname, 'resources', 'logo.ico'), // Path to your icon,
fullscreen: true, // This will make the window fullscreen when opened
...(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
autoUpdater.on('update-available', () => {
dialog.showMessageBox({
type: 'info',
title: 'Mise à jour disponible',
message: 'Une nouvelle version est disponible. Téléchargement en cours...'
})
})
// When the update is downloaded
autoUpdater.on('update-downloaded', (info) => {
dialog
.showMessageBox({
type: 'info',
title: 'Mise à jour prête',
message: `La version ${info.version} a été téléchargée. Redémarrer maintenant ?`,
buttons: ['Redémarrer', 'Plus tard']
})
.then((result) => {
if (result.response === 0) {
autoUpdater.quitAndInstall()
}
})
})
// If an error occurs
autoUpdater.on('error', (error) => {
dialog.showErrorBox('Update Error', error == null ? 'Unknown' : error.message)
})
// Quit the app when all windows are closed, except on macOS
// Quit when all windows are closed, except on macOS. There, it's common
// for applications and their menu bar to stay active until the user quits
// explicitly with Cmd + Q.
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 {
nom,
prenom,
photos,
date_de_naissances,
niveau,
annee_scolaire,
status,
num_inscription,
mention_id,
sexe,
nationaliter,
cin,
date_delivrence,
annee_bacc,
serie,
boursier,
domaine,
contact,
parcours
} = credentials
const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription } =
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,
mention_id,
sexe,
nationaliter,
cin,
date_delivrence,
annee_bacc,
serie,
boursier,
domaine,
contact,
parcours
num_inscription
)
return insert
@ -411,28 +192,8 @@ ipcMain.handle('insertNiveau', async (event, credentials) => {
// event for updating etudiants
ipcMain.handle('updateETudiants', async (event, credentials) => {
const {
nom,
prenom,
photos,
date_de_naissances,
niveau,
annee_scolaire,
status,
mention_id,
num_inscription,
id,
sexe,
nationalite,
cin,
date_delivrance,
annee_bacc,
serie,
boursier,
domaine,
contact,
parcours
} = credentials
const { nom, prenom, photos, date_de_naissances, niveau, annee_scolaire, num_inscription, id } =
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,
sexe,
nationalite,
cin,
date_delivrance,
annee_bacc,
serie,
boursier,
domaine,
contact,
parcours
id
)
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,
mention_id,
formData,
annee_scolaire
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
)
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
})

108
src/main/index.js
View File

@ -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
// updateStudents,
// updateNessesaryTable
updateCurrentYears,
updateStudents,
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
.showMessageBox({
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) => {
buttons: ['Redémarrer', 'Plus tard'],
}).then((result) => {
if (result.response === 0) {
autoUpdater.quitAndInstall()
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
})

210
src/preload/index.backup.js
View File

@ -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
}

4
src/preload/index.js
View File

@ -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')

2
src/renderer/src/components/AddAnneeScolaire.jsx
View File

@ -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 {

4
src/renderer/src/components/AddMatiere.jsx
View File

@ -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)
}

2
src/renderer/src/components/AddMention.jsx
View File

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

5
src/renderer/src/components/AddNiveau.jsx
View File

@ -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à`
}
}
}

8
src/renderer/src/components/AddParcours.jsx
View File

@ -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: ''
})
}
}

2
src/renderer/src/components/AnneeScolaire.jsx
View File

@ -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)

2
src/renderer/src/components/AssignMatiereToMention.jsx
View File

@ -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)
}
}

2
src/renderer/src/components/AssingMatiereToSemestre.jsx
View File

@ -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)
}
}

4
src/renderer/src/components/Login.jsx
View File

@ -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)
}
}
}

2
src/renderer/src/components/Matieres.jsx
View File

@ -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)

2
src/renderer/src/components/Mentions.jsx
View File

@ -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)

3
src/renderer/src/components/ModalAddProf.jsx
View File

@ -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({

4
src/renderer/src/components/Niveau.jsx
View File

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

2
src/renderer/src/components/ParcourMatiere.jsx
View File

@ -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()
}
}

9
src/renderer/src/components/SingleAnneeScolaire.jsx
View File

@ -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'),
fin: dayjs(scolaire.fin).format('YYYY-MM-DD'),
debut: scolaire.debut,
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 {

4
src/renderer/src/components/SingleMatiere.jsx
View File

@ -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 !')
}

13
src/renderer/src/components/SingleNiveau.jsx
View File

@ -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)
console.log(response)
if (response.success) {
if (response.changes == 1) {
setOpen(true)
}
if (!response.success) {
errorRef.current.textContent = `${formData.nom} existe déjà`
if (response.code) {
nomError.current.textContent = `${formData.nom} existe déjà`
}
}
// }
}
/**

2
src/renderer/src/components/SinleMention.jsx
View File

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

2
src/renderer/src/components/UpdateModalProf.jsx
View File

@ -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
}

2
src/renderer/src/components/UpdateParcour.jsx
View File

@ -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
}

4
src/renderer/src/components/validation/Login.js
View File

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