Ajout du support de MYSQL

autopost/common.sh

@@ -34,3 +34,16 @@ SOULIGNE='\e[4m'
 CLIGNOTANT='\e[5m'
 INVERSE='\e[7m'
 NORMAL='\e[0m'
+
+db_query() {
+	local sql="$1"
+	if [ "$dbtype" = "sqlite" ]; then
+		sqlite3 "$DB_FILE" "$sql"
+	else
+		# Le séparateur par défaut de --batch est tabulation
+		mysql --batch --raw --default-character-set=utf8mb4 \
+			-h "$MYSQL_HOST" -P "$MYSQL_PORT" \
+			-u "$MYSQL_USER" -p"$MYSQL_PASS" \
+			-D "$MYSQL_DB" -e "$sql" | sed '1d' | tr '\t' '|'
+	fi
+}

autopost/conf.sh

@@ -2,7 +2,7 @@
 #CONFIG A MODIF
 URL_API="A NOUS DEMANDER SUR DISCORD"
 APIKEY="A RETROUVER DANS VOTRE PROFIL"
-DB_FILE="/home/$USER/autopost/base_autopost.db"
+
 DOSSIER_GLOBAL="/home/$USER/"
 DOSSIER_NFO="/home/$USER/autopost/mediainfo/"
 DOSSIER_LOGS="/home/$USER/autopost/logs/"
@@ -16,5 +16,12 @@ NG_USER=""
 NG_PASS=""
 NG_NBR_CONN=""
 
+dbtype="sqlite"    # ou "mysql"
+DB_FILE="/home/$USER/autopost/base_autopost.db"
+MYSQL_HOST=""
+MYSQL_PORT=
+MYSQL_USER=""
+MYSQL_PASS=""
+MYSQL_DB=""
 
 

autopost/config.js

@@ -9,6 +9,13 @@ module.exports = {
   // Chemin vers le fichier de base de données SQLite
   dbFile: path.join(__dirname, 'base_autopost.db'),
   
+  //MySQL
+  DB_HOST: '',
+  DB_PORT: ,
+  DB_USER: '',
+  DB_PASSWORD: '',
+  DB_DATABASE: '',
+
   // Chemins personnalisables pour les dossiers
   finishdirectory: path.join(__dirname, 'FINIS'),
   logdirectory: path.join(__dirname, 'logs'),

autopost/db.js

@@ -0,0 +1,90 @@
+// db.js
+const config = require('./config');
+
+let db, mysqlPool, sqlite3;
+const dbtype = config.dbtype;
+
+if (dbtype === 'mysql') {
+	const mysql = require('mysql2/promise');
+	mysqlPool = mysql.createPool({
+		host: config.DB_HOST,
+		port: config.DB_PORT,
+		user: config.DB_USER,
+		password: config.DB_PASSWORD,
+		database: config.DB_DATABASE,
+		waitForConnections: true,
+		connectionLimit: 10,
+	});
+
+	db = {
+		async query(sql, params = []) {
+			return await mysqlPool.query(sql, params);
+		},
+		async close() {
+			await mysqlPool.end();
+		}
+	};
+	async function testConnection() {
+		try {
+			const conn = await mysqlPool.getConnection();
+			await conn.ping();
+			conn.release();
+			console.log('[DATABASE] Connexion MySQL OK');
+		} catch (err) {
+			console.error('[DATABASE] Échec connexion MySQL:', err.message);
+			process.exit(1);
+		}
+	}
+	db.testConnection = testConnection;
+} else {
+	// SQLite
+	sqlite3 = require('sqlite3').verbose();
+	db = {
+		async query(sql, params = []) {
+			return new Promise((resolve, reject) => {
+				const lowered = sql.trim().toLowerCase();
+				let base = new sqlite3.Database(config.dbFile, lowered.startsWith('select') ? sqlite3.OPEN_READONLY : sqlite3.OPEN_READWRITE);
+				if (lowered.startsWith('select') && lowered.includes('count(')) {
+					base.get(sql, params, (err, row) => {
+						base.close();
+						if (err) return reject(err);
+						resolve([[row]]);
+					});
+				} else if (lowered.startsWith('select')) {
+					base.all(sql, params, (err, rows) => {
+						base.close();
+						if (err) return reject(err);
+						resolve([rows]);
+					});
+				} else {
+					base.run(sql, params, function(err) {
+						base.close();
+						if (err) return reject(err);
+						resolve([{ affectedRows: this.changes }]);
+					});
+				}
+			});
+		},
+		async close() {}
+	};
+	async function testConnection() {
+		try {
+			let base = new sqlite3.Database(config.dbFile);
+			base.get('SELECT 1', [], (err, row) => {
+				base.close();
+				if (err) {
+					console.error('[DATABASE] Échec connexion SQLite:', err.message);
+					process.exit(1);
+				} else {
+					console.log('[DATABASE] Connexion SQLite OK');
+				}
+			});
+		} catch (err) {
+			console.error('[DATABASE] Échec connexion SQLite:', err.message);
+			process.exit(1);
+		}
+	}
+	db.testConnection = testConnection;
+}
+
+module.exports = db;

autopost/posteur.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
-source $HOME/autopost/common.sh
+
+source /home/$USER/autopost/common.sh
 
 # Vérification et création des dossiers
 for dossier in "$DOSSIER_NFO" "$DOSSIER_NZB_ATTENTE" "$DOSSIER_NZB_FINAL" "$DOSSIER_LOGS" "tmp"
@@ -28,10 +29,11 @@ checkusenet(){
 	 fi
 }
 
-cd ${DOSSIER_GLOBAL}
+cd "${DOSSIER_GLOBAL}"
 
 while true; do
-	verif=$(sqlite3 "$DB_FILE" "BEGIN IMMEDIATE; SELECT id, nom FROM release WHERE status = 0 LIMIT 1; COMMIT;")
+	# Utilisation universelle
+	verif=$(db_query "SELECT id, nom FROM \`release\` WHERE status = 0 LIMIT 1;")
 	if [ -n "$verif" ]; then
 		id=$(echo "$verif" | awk -F "|" '{print $1}' | xargs)
 		name=$(echo "$verif" | awk -F "|" '{print $2}' | xargs)
@@ -40,19 +42,16 @@ while true; do
 
 		echo -e "${VERT}DEBUT DE TRAITEMENT DE ${FILESANSEXT}${NORMAL}" | tee -a "$LOG"
 		echo -e "${CYAN}CREATION DES PAR2${NORMAL}" | tee -a "$LOG"
-		# Lancement de parpar et redirection vers tee sans sous-shell
+		parpar -s10M -S -m4096M -t16 -r20% -O -o "${FILESANSEXT}.par2" "${name}" \
-		parpar -s10M -r20%+2 -m4096M -p1l -o "${FILESANSEXT}.par2" "${name}" \
 			> >(tee -a "$LOG") 2> >(tee -a "$LOG" >&2)
 		ret=$?
 		if [ $ret -ne 0 ]; then
 			echo -e "${ROUGE}Erreur parpar (code $ret). Marquage en échec.${NORMAL}" | tee -a "$LOG"
-			sqlite3 "$DB_FILE" \
+			db_query "UPDATE \`release\` SET status = 2 WHERE id = ${id};"
-				"BEGIN IMMEDIATE; UPDATE release SET status = 2 WHERE id = ${id}; COMMIT;"
 			rm -f "${FILESANSEXT}.par2" "${FILESANSEXT}.vol*"
 			continue
 		fi
 
-		# Suite du traitement loggué
 		{
 			echo -e "${VERT}UPLOAD SUR USENET${NORMAL}"
 			checkusenet
@@ -72,7 +71,7 @@ while true; do
 				if [[ ${nzbsizebit} -le ${jsonsizebit} ]] || [[ ${nzbsizebit} = "NAN" ]]; then
 					echo -e "${ROUGE}PROBLEME TAILLE NZB${NORMAL}"
 					rm "${DOSSIER_NZB_ATTENTE}${FILESANSEXT}.nzb" "${FILESANSEXT}.par2" "${FILESANSEXT}.vol*"
-					sqlite3 "$DB_FILE" "BEGIN IMMEDIATE; UPDATE release SET status = 2 WHERE id = ${id}; COMMIT;"
+					db_query "UPDATE \`release\` SET status = 2 WHERE id = ${id};"
 				else
 					echo -e "${CYAN}ENVOI SUR LE SITE${NORMAL}"
 					curl -s -k -L -m 60 --output /dev/null \
@@ -88,7 +87,7 @@ while true; do
 					mv "${DOSSIER_NZB_ATTENTE}${FILESANSEXT}.7z" "${DOSSIER_NZB_FINAL}${first_char}/"
 					rm -rf "${FILESANSEXT}"*
 					rm "${DOSSIER_NZB_ATTENTE}${FILESANSEXT}.nzb"
-					sqlite3 "$DB_FILE" "BEGIN IMMEDIATE; UPDATE release SET status = 1 WHERE id = ${id}; COMMIT;"
+					db_query "UPDATE \`release\` SET status = 1 WHERE id = ${id};"
 					echo -e "${VERT}FIN DE TRAITEMENT DE ${FILESANSEXT}${NORMAL}"
 				fi
 			else
@@ -96,5 +95,5 @@ while true; do
 			fi
 		} > >(tee -a "$LOG") 2>&1
 	fi
-	attente 10
+	attente 3
 done

autopost/server.js

@@ -1,15 +1,15 @@
 const express = require('express');
 const session = require('express-session');
-const sqlite3 = require('sqlite3').verbose();
 const path = require('path');
 const fs = require('fs');
 const AnsiToHtml = require('ansi-to-html');
 const convert = new AnsiToHtml();
 const { exec } = require('child_process');
 const os = require('os');
-
-// Import de la configuration depuis config.js
 const config = require('./config');
+const db = require('./db');
+
+db.testConnection(); // vérification au démarrage
 
 const app = express();
 const port = config.port;
@@ -17,33 +17,20 @@ const port = config.port;
 // Middleware pour parser les formulaires POST
 app.use(express.urlencoded({ extended: true }));
 
-// Configuration des sessions en utilisant le secret depuis la config
 app.use(session({
 	secret: config.sessionSecret,
 	resave: false,
 	saveUninitialized: false
 }));
 
-// Servir des fichiers statiques (CSS, images, etc.)
 app.use(express.static('public'));
 
-// Chemin vers la base SQLite défini dans la config
-const DB_FILE = config.dbFile;
-
-// Création du routeur pour /autopost
 const autopostRouter = express.Router();
 
-// Servir les fichiers statiques dans le contexte du routeur
 autopostRouter.use('/js', express.static(path.join(__dirname, '../node_modules/@tailwindcss/browser/dist')));
-
-// Servir les fichiers jQuery depuis node_modules/jquery/dist
 autopostRouter.use('/jquery', express.static(path.join(__dirname, '../node_modules/jquery/dist')));
 
-/* -------------------------------------------------------------------------
+// --------------------------- Auth non protégée -----------------------------
-   Routes non protégées (login, logout) sous /autopost
-------------------------------------------------------------------------- */
-
-// Affichage du formulaire de login à l'URL /autopost/login
 autopostRouter.get('/login', (req, res) => {
   res.send(`
 	<!DOCTYPE html>
@@ -73,7 +60,6 @@ autopostRouter.get('/login', (req, res) => {
   `);
 });
 
-// Traitement du formulaire de login en utilisant la config pour vérifier les identifiants
 autopostRouter.post('/login', (req, res) => {
 	const { username, password } = req.body;
 	if (username === config.auth.username && password === config.auth.password) {
@@ -83,16 +69,11 @@ autopostRouter.post('/login', (req, res) => {
 		res.send('Identifiants invalides. <a href="/autopost/login">Réessayer</a>');
 	}
 });
-
-// Déconnexion
 autopostRouter.get('/logout', (req, res) => {
 	req.session.destroy();
 	res.redirect('/autopost/login');
 });
 
-/* -------------------------------------------------------------------------
-   Middleware de protection pour les routes suivantes
-------------------------------------------------------------------------- */
 function checkAuth(req, res, next) {
 	if (req.session && req.session.authenticated) {
 		next();
@@ -102,43 +83,22 @@ function checkAuth(req, res, next) {
 }
 autopostRouter.use(checkAuth);
 
-/* -------------------------------------------------------------------------
+// --------------------------- PAGE PRINCIPALE -----------------------------
-   Route GET principale pour /autopost avec pagination
+autopostRouter.get('/', async (req, res) => {
-------------------------------------------------------------------------- */
-autopostRouter.get('/', (req, res) => {
   const limit = 100; // enregistrements par page
   const page = parseInt(req.query.page) || 1;
   const offset = (page - 1) * limit;
 
-  let db = new sqlite3.Database(DB_FILE, sqlite3.OPEN_READONLY, (err) => {
+  try {
-	if (err) {
-	  console.error(err.message);
-	  return res.status(500).send("Erreur lors de l'ouverture de la base de données.");
-	}
-  });
-
 	// Récupérer le nombre total d'enregistrements
-  const countQuery = "SELECT COUNT(*) as total FROM release";
+	const [countResult] = await db.query("SELECT COUNT(*) as total FROM `release`");
-  db.get(countQuery, [], (err, countResult) => {
+	const totalRecords = countResult[0].total;
-	if (err) {
-	  console.error(err.message);
-	  res.status(500).send("Erreur lors du comptage des enregistrements.");
-	  return;
-	}
-	const totalRecords = countResult.total;
 	const totalPages = Math.ceil(totalRecords / limit);
 
-	const query = `
+	const [rows] = await db.query(
-	  SELECT nom, status, id FROM release
+	  "SELECT nom, status, id FROM `release` ORDER BY (status = 2) DESC, id DESC LIMIT ? OFFSET ?",
-	  ORDER BY (status = 2) DESC, id DESC
+	  [limit, offset]
-	  LIMIT ${limit} OFFSET ${offset};
+	);
-	`;
-	db.all(query, [], (err, rows) => {
-	  if (err) {
-		console.error(err.message);
-		res.status(500).send("Erreur lors de la requête.");
-		return;
-	  }
 
 	let html = `
 	<!DOCTYPE html>
@@ -146,12 +106,11 @@ autopostRouter.get('/', (req, res) => {
 	<head>
 	  <meta charset="UTF-8">
 	  <title>Suivi Autopost</title>
-		  <!-- Inclusion de Tailwind CSS et jQuery -->
 	  <script src="js/index.global.js"></script>
 	  <script src="jquery/jquery.min.js"></script>
+	  <link href="https://fonts.googleapis.com/css?family=Roboto:400,700&display=swap" rel="stylesheet">
 	</head>
 	<body class="bg-slate-900 text-white font-sans p-4">
-		  <!-- Conteneur "fluid" -->
 	  <div class="w-full px-4">
 		<h1 class="text-3xl font-bold mb-4">Suivi Autopost</h1>
 		<p class="mb-4">
@@ -160,7 +119,6 @@ autopostRouter.get('/', (req, res) => {
 
 		<input type="text" id="searchInput" placeholder="Rechercher..." 
 			   class="p-2 mb-4 border border-gray-300 rounded w-full"/>
-			<!-- Pagination avec Tailwind -->
 		<nav aria-label="Page navigation" class="mb-4">
 		  <ul class="inline-flex items-center -space-x-px">
 			<li>
@@ -196,7 +154,7 @@ autopostRouter.get('/', (req, res) => {
 	rows.forEach(row => {
 	  let statusText = '';
 	  let statusClass = '';
-		switch (row.status) {
+	  switch (parseInt(row.status)) {
 		case 0:
 		  statusText = 'EN ATTENTE';
 		  statusClass = 'bg-cyan-500 text-black font-bold';
@@ -486,37 +444,29 @@ autopostRouter.get('/', (req, res) => {
 	</html>
 	`;
 	res.send(html);
-	  db.close();
+  } catch (err) {
-	});
+	console.error(err.message);
-  });
+	res.status(500).send("Erreur lors de la requête DB.");
+  }
 });
 
-/* -------------------------------------------------------------------------
+// --------------------------- Recherche -----------------------------
-   Route GET pour la recherche côté serveur
+autopostRouter.get('/search', async (req, res) => {
-------------------------------------------------------------------------- */
-autopostRouter.get('/search', (req, res) => {
 	const q = req.query.q || "";
 	const searchQuery = "%" + q + "%";
-  let db = new sqlite3.Database(DB_FILE, sqlite3.OPEN_READONLY, (err) => {
+	try {
-	if (err) {
+		const [rows] = await db.query(
-	  console.error(err.message);
+			"SELECT nom, status, id FROM `release` WHERE nom LIKE ? ORDER BY id DESC LIMIT 500",
-	  return res.status(500).json({ error: "Erreur lors de l'ouverture de la base de données." });
+			[searchQuery]
-	}
+		);
-  });
+		res.json(rows);
-  db.all("SELECT nom, status, id FROM release WHERE nom LIKE ? ORDER BY id DESC LIMIT 500", [searchQuery], (err, rows) => {
+	} catch (err) {
-	if (err) {
 		console.error(err.message);
 		res.status(500).json({ error: "Erreur lors de la requête." });
-	  return;
 	}
-	res.json(rows);
-	db.close();
-  });
 });
 
-/* -------------------------------------------------------------------------
+// --------------------------- Log -----------------------------
-   Route GET pour récupérer le contenu d'un fichier log
-------------------------------------------------------------------------- */
 autopostRouter.get('/log', (req, res) => {
   const filename = req.query.name;
   if (!filename) {
@@ -534,9 +484,7 @@ autopostRouter.get('/log', (req, res) => {
   });
 });
 
-/* -------------------------------------------------------------------------
+// --------------------------- Mediainfo -----------------------------
-   Route GET pour récupérer le contenu d'un fichier mediainfo
-------------------------------------------------------------------------- */
 autopostRouter.get('/mediainfo', (req, res) => {
   const filename = req.query.name;
   if (!filename) {
@@ -559,9 +507,7 @@ autopostRouter.get('/mediainfo', (req, res) => {
   });
 });
 
-/* -------------------------------------------------------------------------
+// --------------------------- Download -----------------------------
-   Route GET pour télécharger le fichier NZB
-------------------------------------------------------------------------- */
 autopostRouter.get('/dl', (req, res) => {
   const filename = req.query.name;
   if (!filename) {
@@ -603,65 +549,44 @@ autopostRouter.get('/dl', (req, res) => {
   });
 });
 
-/* -------------------------------------------------------------------------
+// --------------------------- Édition -----------------------------
-   Route POST pour mettre à jour le statut (édition)
+autopostRouter.post('/edit/:id', async (req, res) => {
-------------------------------------------------------------------------- */
-autopostRouter.post('/edit/:id', (req, res) => {
 	const id = req.params.id;
 	const newStatus = req.body.status;
-  let db = new sqlite3.Database(DB_FILE, sqlite3.OPEN_READWRITE, (err) => {
+	try {
-	if (err) {
+		await db.query("UPDATE `release` SET status = ? WHERE id = ?", [newStatus, id]);
-	  console.error(err.message);
+		if (req.xhr || req.headers.accept.indexOf('json') > -1) {
-	  return res.status(500).send("Erreur lors de l'ouverture de la base de données.");
+			res.json({ success: true });
+		} else {
+			res.redirect("/autopost/");
 		}
-  });
+	} catch (err) {
-  db.run("UPDATE release SET status = ? WHERE id = ?", [newStatus, id], function(err) {
-	if (err) {
 		console.error(err.message);
 		res.status(500).send("Erreur lors de la mise à jour.");
-	  return;
 	}
+});
+
+// --------------------------- Suppression -----------------------------
+autopostRouter.post('/delete/:id', async (req, res) => {
+	const id = req.params.id;
+	try {
+		await db.query("DELETE FROM `release` WHERE id = ?", [id]);
 		if (req.xhr || req.headers.accept.indexOf('json') > -1) {
 			res.json({ success: true });
 		} else {
 			res.redirect("/autopost/");
 		}
-	db.close();
+	} catch (err) {
-  });
-});
-
-/* -------------------------------------------------------------------------
-   Route POST pour supprimer un enregistrement
-------------------------------------------------------------------------- */
-autopostRouter.post('/delete/:id', (req, res) => {
-  const id = req.params.id;
-  let db = new sqlite3.Database(DB_FILE, sqlite3.OPEN_READWRITE, (err) => {
-	if (err) {
-	  console.error(err.message);
-	  return res.status(500).send("Erreur lors de l'ouverture de la base de données.");
-	}
-  });
-  db.run("DELETE FROM release WHERE id = ?", [id], function(err) {
-	if (err) {
 		console.error(err.message);
 		res.status(500).send("Erreur lors de la suppression.");
-	  return;
 	}
-	if (req.xhr || req.headers.accept.indexOf('json') > -1) {
-	  res.json({ success: true });
-	} else {
-	  res.redirect("/autopost/");
-	}
-	db.close();
-  });
 });
 
-// Redirection de la route GET d'édition si accès direct
+// Redirection accès direct GET /edit/:id
 autopostRouter.get('/edit/:id', (req, res) => {
 	res.redirect("/autopost/");
 });
 
-// Monter le routeur sur le chemin /autopost
 app.use('/autopost', autopostRouter);
 
 app.listen(port, () => {

install.sh

@@ -92,28 +92,67 @@ else
 	fi
 fi
 
-# Vérifier et installer sqlite3 si manquant
+# Demande à l'utilisateur
+echo "Quel système de base de données voulez-vous utiliser ?"
+select BDD in "SQLite" "MySQL"; do
+	case $BDD in
+		"SQLite")
+			echo "Vous avez choisi SQLite."
+			# Bloc vérification/install sqlite3
 			if command -v sqlite3 > /dev/null 2>&1; then
 				LISTE_APPLIS+=("sqlite3")
 			else
 				echo -e "${ROUGE}sqlite3 est manquant. Installation en cours...${NORMAL}"
 				if $sudook; then
-		sudo apt install sqlite3
+					sudo apt install -y sqlite3
 					LISTE_APPLIS+=("sqlite3")
 					echo -e "${VERT}sqlite3 installé${NORMAL}"
 				else
 					curl -L -o sqlite-tools.zip "https://www.sqlite.org/2024/sqlite-tools-linux-x64-3470000.zip"
 					unzip sqlite-tools.zip -d "$BIN_DIR"
 					chmod 777 "$BIN_DIR/sqlite3"
-		
+					# Nettoyage
-		# Nettoyage des fichiers inutiles
 					rm -rf sqlite-tools.zip "$BIN_DIR/sqlite-tools-linux-x64-3480000" "$BIN_DIR/sqldiff" "$BIN_DIR/sqlite3_analyzer" "$BIN_DIR/sqlite3_rsync"
-		
 					LISTE_APPLIS+=("$BIN_DIR/sqlite3")
 					echo -e "${VERT}sqlite3 installé dans $BIN_DIR${NORMAL}"
-	
 				fi
 			fi
+			break
+			;;
+		"MySQL")
+			echo "Vous avez choisi MySQL."
+			if command -v mysql > /dev/null 2>&1; then
+				LISTE_APPLIS+=("mysql")
+				echo -e "${VERT}MySQL est disponible${NORMAL}"
+				# Place ici le code MySQL à exécuter
+			else
+				echo -e "${ROUGE}MySQL n'est pas installé. Bascule automatique sur SQLite.${NORMAL}"
+				# Bloc vérification/install sqlite3 (copié plus haut)
+				if command -v sqlite3 > /dev/null 2>&1; then
+					LISTE_APPLIS+=("sqlite3")
+				else
+					echo -e "${ROUGE}sqlite3 est manquant. Installation en cours...${NORMAL}"
+					if $sudook; then
+						sudo apt install -y sqlite3
+						LISTE_APPLIS+=("sqlite3")
+						echo -e "${VERT}sqlite3 installé${NORMAL}"
+					else
+						curl -L -o sqlite-tools.zip "https://www.sqlite.org/2024/sqlite-tools-linux-x64-3470000.zip"
+						unzip sqlite-tools.zip -d "$BIN_DIR"
+						chmod 777 "$BIN_DIR/sqlite3"
+						rm -rf sqlite-tools.zip "$BIN_DIR/sqlite-tools-linux-x64-3480000" "$BIN_DIR/sqldiff" "$BIN_DIR/sqlite3_analyzer" "$BIN_DIR/sqlite3_rsync"
+						LISTE_APPLIS+=("$BIN_DIR/sqlite3")
+						echo -e "${VERT}sqlite3 installé dans $BIN_DIR${NORMAL}"
+					fi
+				fi
+			fi
+			break
+			;;
+		*)
+			echo "Choix invalide."
+			;;
+	esac
+done
 
 # Vérifier et installer jq si manquant
 if command -v jq > /dev/null 2>&1; then
@@ -314,7 +353,7 @@ export NVM_DIR="$HOME/.nvm"
 # Vérification des modules npm nécessaires
 log "Vérification des modules npm requis..."
 
-modules=("express" "express-session" "sqlite3" "ansi-to-html" "@tailwindcss/browser" "autoprefixer" "jquery")
+modules=("express" "express-session" "sqlite3" "ansi-to-html" "@tailwindcss/browser" "autoprefixer" "jquery" "mysql2")
 missing_modules=()
 
 for module in "${modules[@]}"; do
@@ -339,6 +378,12 @@ if [ ! -f "$AUTOPOST_DIR/server.js" ]; then
   updated="1"
 fi
 
+if [ ! -f "$AUTOPOST_DIR/db.js" ]; then
+  log "Téléchargement de db.js..."
+  wget -q -O "$AUTOPOST_DIR/db.js" "https://tig.unfr.pw/UNFR/postauto/raw/branch/main/autopost/db.js"
+  updated="1"
+fi
+
 if [ ! -f "$AUTOPOST_DIR/config.js" ]; then
   log "Téléchargement de config.js..."
   wget -q -O "$AUTOPOST_DIR/config.js" "https://tig.unfr.pw/UNFR/postauto/raw/branch/main/autopost/config.js"

update.sh

@@ -209,7 +209,7 @@ export NVM_DIR="$HOME/.nvm"
 # Vérification des modules npm nécessaires
 log "Vérification des modules npm requis..."
 
-modules=("express" "express-session" "sqlite3" "ansi-to-html" "@tailwindcss/browser" "jquery")
+modules=("express" "express-session" "sqlite3" "ansi-to-html" "@tailwindcss/browser" "jquery" "mysql2")
 missing_modules=()
 
 for module in "${modules[@]}"; do
@@ -235,12 +235,20 @@ if [ ! -f "$AUTOPOST_DIR/server.js" ]; then
   updated="1"
 fi
 
+if [ ! -f "$AUTOPOST_DIR/db.js" ]; then
+  log "Téléchargement de db.js..."
+  wget -q -O "$AUTOPOST_DIR/db.js" "https://tig.unfr.pw/UNFR/postauto/raw/branch/main/autopost/db.js"
+  updated="1"
+fi
+
 if [ ! -f "$AUTOPOST_DIR/config.js" ]; then
   log "Téléchargement de config.js..."
   wget -q -O "$AUTOPOST_DIR/config.js" "https://tig.unfr.pw/UNFR/postauto/raw/branch/main/autopost/config.js"
   echo -e "${BLEU}Installation terminée. Vous pouvez maintenant configurer $AUTOPOST_DIR/config.js.${NORMAL}"
 fi
 
+
+
 # Vérifier et installer 7z si manquant
 if command -v 7z > /dev/null 2>&1; then
 	LISTE_APPLIS+=("7z")