C-university/database/Models/Notes.js

const { database } = require('../database.backup')
const { getNiveau } = require('./Niveau')
const { matiereSysteme } = require('../function/System')

/**
 * Function to insert notes into the database
 * @param {Object} formData - The form data containing subject names and values
 * @param {number} etudiant_id - The student ID
 * @param {string} etudiant_niveau - The student level
 * @returns {Promise} - Promise resolving to the database response or an error
 */
async function insertNote(etudiant_id, etudiant_niveau, mention_id, formData, annee_scolaire) {
  // Extract keys and values dynamically
  const matiere_id = Object.keys(formData)
  const values = Object.values(formData)

  const query = database.prepare(
    `INSERT INTO notes (etudiant_id, matiere_id, etudiant_niveau, mention_id, note, annee_scolaire) VALUES (?, ?, ?, ?, ?, ?)`
  )

  const insertRepechQuery = database.prepare(
    `INSERT INTO notesrepech (etudiant_id, matiere_id, etudiant_niveau, mention_id, note, annee_scolaire) VALUES (?, ?, ?, ?, ?, ?)`
  )

  console.log(annee_scolaire)
  try {
    let response
    let newMatiereId = []

    // run the session normale
    database.transaction(() => {
      for (let j = 0; j < matiere_id.length; j++) {
        if (values[j] < 10) {
          newMatiereId.push(matiere_id[j])
        }

        response = query.run(
          etudiant_id,
          matiere_id[j],
          etudiant_niveau,
          mention_id,
          parseFloat(values[j].replace(',', '.')) || 0,
          annee_scolaire
        )
      }
    })()

    // run the second session and set it to be 0 to display it from screen
    database.transaction(() => {
      for (let j = 0; j < newMatiereId.length; j++) {
        response = insertRepechQuery.run(
          etudiant_id,
          newMatiereId[j],
          etudiant_niveau,
          mention_id,
          0,
          annee_scolaire
        )
      }
    })()

    return response
  } catch (error) {
    return error
  }
}

/**
 *
 * @returns promise
 */
async function getNoteOnline() {
  const query = database.prepare('SELECT notes.* FROM notes ')

  try {
    let response = await query.all()

    return response
  } catch (error) {
    return error
  }
}

/**
 *
 * @returns promise
 */
async function getNote(id, niveau, mention_id) {
  let semestre = await matiereSysteme(niveau)

  const query = database.prepare(
    'SELECT notes.*, matieres.* FROM notes JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ? AND notes.etudiant_niveau = ?'
  )
  const 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 = ?
  `)

  let res = await matiereQuery.all(`%${semestre[0]}%`, `%${semestre[1]}%`, mention_id)

  let response = await query.all(id, niveau)
  const infoEtudiants = database.prepare('SELECT * FROM etudiants WHERE id = ?')
  let etudiant = await infoEtudiants.get(id)

  let arrayResponseIdMatiere = []
  for (let index = 0; index < response.length; index++) {
    arrayResponseIdMatiere.push(response[index].matiere_id)
  }

  const filteredIds = res
    .filter((matiere) => !arrayResponseIdMatiere.includes(matiere.id))
    .map((matiere) => matiere.id)

  const json = filteredIds.reduce((acc, id) => {
    acc[id] = '0'
    return acc
  }, {})

  const query2 = database.prepare(
    'SELECT notes.*, matieres.* FROM notes JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ? AND notes.etudiant_niveau = ?'
  )

  try {
    let response2 = query2.all(id, niveau)
    return response2
  } catch (error) {
    console.error('Error in query2:', error)
    return error
  }
}

/**
 * Verify if a student has notes
 * @returns {Promise<Array>} - Promise resolving to an array of notes or an empty array
 */
async function verifyEtudiantIfHeHasNotes() {
  try {
    // Prepare the query to filter by etudiant_id and etudiant_niveau
    const query = database.prepare('SELECT DISTINCT etudiant_id, etudiant_niveau FROM notes')

    // Execute the query with the provided parameters
    const response = query.all()

    // Return the response
    return response
  } catch (error) {
    console.error('Error verifying student notes:', error)
    throw error
  }
}

/**
 * function to show moyenne in screen
 *
 * @returns promise
 */
async function showMoyen(niveau, scolaire) {
  const query = database.prepare(
    `SELECT DISTINCT etudiant_id FROM notes WHERE etudiant_niveau = ? AND annee_scolaire = ?`
  )

  let etudiantWithNotes = await query.all(niveau, scolaire)

  let allEtudiantWithNotes = []

  const query2 = database.prepare(
    'SELECT notes.*, etudiants.*, matieres.id, matieres.nom AS nomMat, matieres.credit FROM notes INNER JOIN etudiants ON (notes.etudiant_id = etudiants.id) INNER JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ?'
  )

  try {
    for (let index = 0; index < etudiantWithNotes.length; index++) {
      allEtudiantWithNotes.push(query2.all(etudiantWithNotes[index].etudiant_id))
    }

    return allEtudiantWithNotes
  } catch (error) {
    return error
  }
}

/**
 * function used when updating note
 * @param {Object} formData - The form data containing subject names and values
 * @param {string} niveau - The student level
 * @returns {Promise} - Promise resolving to the database response or an error
 */
async function updateNote(formData, niveau, id, mention_id, annee_scolaire) {
  // Extract keys and values dynamically
  const matiere_id = Object.keys(formData)
  const values = Object.values(formData)

  const query = database.prepare(
    'UPDATE notes SET note= ? WHERE etudiant_id = ? AND etudiant_niveau = ? AND matiere_id = ?'
  )

  const clearFromRepech = database.prepare(
    'DELETE FROM notesrepech WHERE etudiant_id = ? AND etudiant_niveau = ? AND matiere_id = ?'
  )
  const insertRepechQuery = database.prepare(
    `INSERT INTO notesrepech (etudiant_id, matiere_id, etudiant_niveau, mention_id, note, annee_scolaire) VALUES (?, ?, ?, ?, ?, ?)`
  )

  const checkRepechQuery = database.prepare(
    'SELECT * FROM notesrepech WHERE etudiant_id = ? AND matiere_id = ? AND etudiant_niveau = ?'
  )

  try {
    let response

    for (let index = 0; index < matiere_id.length; index++) {
      let data = values[index]
      if (typeof data === 'string') {
        data = parseFloat(data.replace(',', '.'))
      } else {
        data = parseFloat(String(data).replace(',', '.'))
      }
      let check = await checkRepechQuery.get(id, matiere_id[index], niveau)
      if (data < 10) {
        if (!check) {
          insertRepechQuery.run(id, matiere_id[index], niveau, mention_id, 0, annee_scolaire)
        }
        response = await query.run(data, id, niveau, matiere_id[index])
      } else {
        clearFromRepech.run(id, niveau, matiere_id[index])
        response = await query.run(data, id, niveau, matiere_id[index])
      }
    }

    return response
  } catch (error) {
    return error
  }
}

async function blockShowMoyene() {
  const query = database.prepare(
    'SELECT DISTINCT etudiant_niveau, annee_scolaire FROM notes ORDER BY annee_scolaire DESC'
  )

  const queryMention = database.prepare('SELECT * FROM mentions')

  try {
    let response = await query.all()
    let mention = await queryMention.all()
    let niveau = response.map((item) => item.etudiant_niveau)
    let annee_scolaire = response.map((item) => item.annee_scolaire)
    const query2 = database.prepare(
      `SELECT notes.*, etudiants.id AS etudiantsId, etudiants.mention_id AS mentionId, etudiants.niveau, matieres.* FROM notes INNER JOIN etudiants ON (notes.etudiant_id = etudiants.id) INNER JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_niveau = ? AND notes.annee_scolaire = ?`
    )

    let allData = []

    for (let index = 0; index < niveau.length; index++) {
      allData.push(await query2.all(niveau[index], annee_scolaire[index]))
    }

    return { response, allData, mention }
  } catch (error) {
    return error
  }
}

/**
 * get all note with matiere for single student
 * @param {*} id
 * @param {*} niveau
 * @param {*} annee_scolaire
 * @returns promise
 */
async function getMatiereAndNote(id, niveau, annee_scolaire) {
  const query = database.prepare(
    'SELECT * FROM notes INNER JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ? AND notes.etudiant_niveau = ? AND notes.annee_scolaire = ?'
  )

  try {
    let response = await query.all(id, niveau, annee_scolaire)

    return response
  } catch (error) {
    return error
  }
}

async function getNotesWithRepechToDisplay(id, anneescolaire, niveau) {
  const queryNoteNormal = database.prepare(
    'SELECT * FROM notes INNER JOIN matieres ON (notes.matiere_id = matieres.id) WHERE notes.etudiant_id = ? AND notes.annee_scolaire = ? AND notes.etudiant_niveau = ?'
  )
  let noteNormal = await queryNoteNormal.all(id, anneescolaire, niveau)

  const queryNoteRepech = database.prepare(
    'SELECT * FROM notesrepech INNER JOIN matieres ON (notesrepech.matiere_id = matieres.id) WHERE notesrepech.etudiant_id = ? AND notesrepech.annee_scolaire = ? AND notesrepech.etudiant_niveau = ?'
  )
  let noteRepech = await queryNoteRepech.all(id, anneescolaire, niveau)

  const semestreQuery = database.prepare(
    'SELECT * FROM semestres INNER JOIN matiere_semestre ON(semestres.id = matiere_semestre.semestre_id)'
  )
  let semestre = await semestreQuery.all()

  return { noteNormal, noteRepech, semestre }
}

module.exports = {
  insertNote,
  getNote,
  showMoyen,
  getNoteOnline,
  verifyEtudiantIfHeHasNotes,
  updateNote,
  blockShowMoyene,
  getMatiereAndNote,
  getNotesWithRepechToDisplay
}