fix de toutes les requêtes pour marcher avec mysql2
continuous-integration/drone/push Build is passing Details

CI/CD
Thomas Chazot 1 year ago
parent 0b471d0eac
commit 9447149ff7

@ -17,7 +17,7 @@ class AuthController {
console.log(req.body) console.log(req.body)
// Vérifier que le pseudo n'existe pas déjà // Vérifier que le pseudo n'existe pas déjà
const [verif, fields] = await databaseService.getUserByPseudo(pseudo); const verif = await databaseService.getUserByPseudo(pseudo);
if (verif) { if (verif) {
res.status(400).json({ error: 'Le pseudo est déjà utilisé.' }); res.status(400).json({ error: 'Le pseudo est déjà utilisé.' });
return; return;
@ -54,7 +54,7 @@ class AuthController {
// Vérifier que le pseudo existe // Vérifier que le pseudo existe
const pseudo = req.body.pseudo; const pseudo = req.body.pseudo;
const [user, fields] = await databaseService.getUserByPseudo(pseudo); const user = await databaseService.getUserByPseudo(pseudo);
if (!user) { if (!user) {
res.status(400).json({ error: 'Le pseudo n\'existe pas.' }); res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
return; return;
@ -107,7 +107,7 @@ class AuthController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if(!user){ if(!user){
res.status(400).json({ error: 'Le pseudo n\'existe pas.' }); res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
@ -130,7 +130,7 @@ class AuthController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if(!user){ if(!user){
res.status(400).json({ error: 'Le pseudo n\'existe pas.' }); res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
return; return;
@ -159,7 +159,7 @@ class AuthController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if(!user){ if(!user){
res.status(400).json({ error: 'Le pseudo n\'existe pas.' }); res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
return; return;

@ -17,10 +17,10 @@ class SessionController {
await db.connect(); await db.connect();
const [dailyMastermindStats, fields] = await db.getDailyMastermindStats(); const dailyMastermindStats = await db.getDailyMastermindStats();
console.log(dailyMastermindStats) console.log(dailyMastermindStats)
res.status(200).json({ tab : [dailyMastermindStats] }); res.status(200).json({ tab : dailyMastermindStats});
} }
catch(error){ catch(error){
console.error(error); console.error(error);
@ -37,7 +37,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [dailyEasyEnigmaStats, fields] = await db.getDailyEnigmaStats(ENIGME_FACILE); const dailyEasyEnigmaStats = await db.getDailyEnigmaStats(ENIGME_FACILE);
res.status(200).json({ tab : dailyEasyEnigmaStats }); res.status(200).json({ tab : dailyEasyEnigmaStats });
} }
@ -56,7 +56,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [dailyMediumEnigmaStats, fields] = await db.getDailyEnigmaStats(ENIGME_MOYEN); const dailyMediumEnigmaStats = await db.getDailyEnigmaStats(ENIGME_MOYEN);
res.status(200).json({ tab : dailyMediumEnigmaStats }); res.status(200).json({ tab : dailyMediumEnigmaStats });
} }
@ -75,7 +75,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [dailyHardEnigmaStats, fields] = await db.getDailyEnigmaStats(ENIGME_DIFFICILE); const dailyHardEnigmaStats = await db.getDailyEnigmaStats(ENIGME_DIFFICILE);
res.status(200).json({ tab : dailyHardEnigmaStats }); res.status(200).json({ tab : dailyHardEnigmaStats });
} }
@ -94,7 +94,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [dailyOnlineStats, fields] = await db.getDailyOnlineStats(); const dailyOnlineStats = await db.getDailyOnlineStats();
@ -120,9 +120,9 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [weeklyMastermindStats, fields] = await db.getWeeklyMastermindStats(); const weeklyMastermindStats = await db.getWeeklyMastermindStats();
console.log(weeklyMastermindStats) console.log(weeklyMastermindStats)
res.status(200).json({ tab : [weeklyMastermindStats] }); res.status(200).json({ tab : weeklyMastermindStats });
} }
catch(error){ catch(error){
console.error(error); console.error(error);
@ -139,7 +139,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [weeklyEasyEnigmaStats, fields] = await db.getWeeklyEnigmaStats(ENIGME_FACILE); const weeklyEasyEnigmaStats = await db.getWeeklyEnigmaStats(ENIGME_FACILE);
res.status(200).json({ tab : weeklyEasyEnigmaStats }); res.status(200).json({ tab : weeklyEasyEnigmaStats });
} }
@ -158,7 +158,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [weeklyMediumEnigmaStats, fields] = await db.getWeeklyEnigmaStats(ENIGME_MOYEN); const weeklyMediumEnigmaStats = await db.getWeeklyEnigmaStats(ENIGME_MOYEN);
res.status(200).json({ tab : weeklyMediumEnigmaStats }); res.status(200).json({ tab : weeklyMediumEnigmaStats });
} }
@ -177,7 +177,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [weeklyHardEnigmaStats, fields] = await db.getWeeklyEnigmaStats(ENIGME_DIFFICILE); const weeklyHardEnigmaStats = await db.getWeeklyEnigmaStats(ENIGME_DIFFICILE);
res.status(200).json({ tab : weeklyHardEnigmaStats }); res.status(200).json({ tab : weeklyHardEnigmaStats });
} }
@ -196,7 +196,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [weeklyOnlineStats, fields] = await db.getWeeklyOnlineStats(); const weeklyOnlineStats = await db.getWeeklyOnlineStats();
res.status(200).json({ tab : weeklyOnlineStats }); res.status(200).json({ tab : weeklyOnlineStats });
} }

@ -21,11 +21,11 @@ class SessionController {
} }
// Récupérer les stats mastermind de l'utilisateur // Récupérer les stats mastermind de l'utilisateur
let [nbGamesMM, i] = await db.getNbGamesMastermindByUserId(req.session.user.idUser); let nbGamesMM = await db.getNbGamesMastermindByUserId(req.session.user.idUser);
nbGamesMM = nbGamesMM.nbGames || 0; nbGamesMM = nbGamesMM.nbGames || 0;
let [bestScoreMM, j] = await db.getBestScoreMastermindByUserId(req.session.user.idUser); let bestScoreMM = await db.getBestScoreMastermindByUserId(req.session.user.idUser);
bestScoreMM = bestScoreMM.bestScore || 0; bestScoreMM = bestScoreMM.bestScore || 0;
let [avgNbTryMM, k] = await db.getAvgNbTryMastermindByUserId(req.session.user.idUser); let avgNbTryMM= await db.getAvgNbTryMastermindByUserId(req.session.user.idUser);
avgNbTryMM = avgNbTryMM.avgNbTry || 0; avgNbTryMM = avgNbTryMM.avgNbTry || 0;
req.session.user.mastermindStats = {nbGames: nbGamesMM, req.session.user.mastermindStats = {nbGames: nbGamesMM,
@ -33,14 +33,14 @@ class SessionController {
avgNbTry: avgNbTryMM}; avgNbTry: avgNbTryMM};
// Récupérer les stats enigme facile // Récupérer les stats enigme facile
let [nbGamesEF, l] = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE); let nbGamesEF = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE);
nbGamesEF = nbGamesEF.nbGames || 0; nbGamesEF = nbGamesEF.nbGames || 0;
let [nbWinsEF, m] = await db.getNbWinsEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE); let nbWinsEF = await db.getNbWinsEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE);
nbWinsEF = nbWinsEF.nbWins || 0; nbWinsEF = nbWinsEF.nbWins || 0;
let ratioEF = (nbWinsEF.nbWins / nbGamesEF.nbGames) * 100 || 0; let ratioEF = (nbWinsEF.nbWins / nbGamesEF.nbGames) * 100 || 0;
let [bestTimeEF, n] = await db.getBestTimeEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE); let bestTimeEF = await db.getBestTimeEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE);
bestTimeEF = bestTimeEF.bestTime || 0; bestTimeEF = bestTimeEF.bestTime || 0;
let [avgTimeEF, o] = await db.getAvgTimeEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE); let avgTimeEF = await db.getAvgTimeEnigmeByUserId(req.session.user.idUser, ENIGME_FACILE);
avgTimeEF = avgTimeEF.avgTime || 0; avgTimeEF = avgTimeEF.avgTime || 0;
req.session.user.easyEnigmaStats = {nbGames: nbGamesEF, req.session.user.easyEnigmaStats = {nbGames: nbGamesEF,
@ -50,11 +50,11 @@ class SessionController {
avgTime: avgTimeEF}; avgTime: avgTimeEF};
// Récupérer les stats enigme moyenne // Récupérer les stats enigme moyenne
let [nbGamesEM, p] = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN); let nbGamesEM, = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN);
nbGamesEM = nbGamesEM.nbGames || 0; nbGamesEM = nbGamesEM.nbGames || 0;
let [bestScoreEM, q] = await db.getBestScoreEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN); let bestScoreEM = await db.getBestScoreEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN);
bestScoreEM = bestScoreEM.bestScore || 0; bestScoreEM = bestScoreEM.bestScore || 0;
let [avgNbTryEM, r] = await db.getAvgScoreEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN); let avgNbTryEM = await db.getAvgScoreEnigmeByUserId(req.session.user.idUser, ENIGME_MOYEN);
avgNbTryEM = avgNbTryEM.avgScore || 0; avgNbTryEM = avgNbTryEM.avgScore || 0;
req.session.user.mediumEnigmaStats = {nbGames: nbGamesEM, req.session.user.mediumEnigmaStats = {nbGames: nbGamesEM,
@ -62,14 +62,14 @@ class SessionController {
avgNbTry: avgNbTryEM}; avgNbTry: avgNbTryEM};
// Récupérer les stats enigme difficile // Récupérer les stats enigme difficile
let [nbGamesED, s] = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE); let nbGamesED = await db.getNbGamesEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE);
nbGamesED = nbGamesED.nbGames || 0; nbGamesED = nbGamesED.nbGames || 0;
let [nbWinsED, t] = await db.getNbWinsEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE); let nbWinsED = await db.getNbWinsEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE);
nbWinsED = nbWinsED.nbWins || 0; nbWinsED = nbWinsED.nbWins || 0;
let ratioED = (nbWinsED.nbWins / nbGamesED.nbGames) * 100 || 0; let ratioED = (nbWinsED.nbWins / nbGamesED.nbGames) * 100 || 0;
let [bestTimeED, u] = await db.getBestTimeEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE); let bestTimeED = await db.getBestTimeEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE);
bestTimeED = bestTimeED.bestTime || 0; bestTimeED = bestTimeED.bestTime || 0;
let [avgTimeED, v] = await db.getAvgTimeEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE); let avgTimeED = await db.getAvgTimeEnigmeByUserId(req.session.user.idUser, ENIGME_DIFFICILE);
avgTimeED = avgTimeED.avgTime || 0; avgTimeED = avgTimeED.avgTime || 0;
req.session.user.hardEnigmaStats = {nbGames: nbGamesED, req.session.user.hardEnigmaStats = {nbGames: nbGamesED,
@ -79,9 +79,9 @@ class SessionController {
avgTime: avgTimeED}; avgTime: avgTimeED};
// Récupérer les stats en ligne de l'utilisateur // Récupérer les stats en ligne de l'utilisateur
let [nbGamesOL, w] = await db.getNbGamesOnlineByUserId(req.session.user.idUser); let nbGamesOL = await db.getNbGamesOnlineByUserId(req.session.user.idUser);
nbGamesOL = nbGamesOL.nbGames || 0; nbGamesOL = nbGamesOL.nbGames || 0;
let [nbWinsOL, x] = await db.getNbWinsOnlineByUserId(req.session.user.idUser); let nbWinsOL = await db.getNbWinsOnlineByUserId(req.session.user.idUser);
nbWinsOL = nbWinsOL.nbWins || 0; nbWinsOL = nbWinsOL.nbWins || 0;
let ratioOL = (nbWinsOL.nbWins / nbGamesOL.nbGames) * 100 || 0; let ratioOL = (nbWinsOL.nbWins / nbGamesOL.nbGames) * 100 || 0;
req.session.user.onlineStats = {nbGames: nbGamesOL, req.session.user.onlineStats = {nbGames: nbGamesOL,
@ -105,7 +105,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [user, _] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
console.log("utilisateur" + user.idUser + " pseudo" + user.pseudo) console.log("utilisateur" + user.idUser + " pseudo" + user.pseudo)
if (!user) { if (!user) {
res.status(200).json({ error: "true", message: 'User not found' }); res.status(200).json({ error: "true", message: 'User not found' });
@ -114,7 +114,7 @@ class SessionController {
await db.updatePseudo(user.idUser, req.body.newPseudo); //* update await db.updatePseudo(user.idUser, req.body.newPseudo); //* update
const [updatedUser, fields] = await db.getUserByPseudo(req.body.newPseudo); const updatedUser = await db.getUserByPseudo(req.body.newPseudo);
console.log("updaetdutilisateur" + updatedUser.idUser + " pseudo" + updatedUser.pseudo) console.log("updaetdutilisateur" + updatedUser.idUser + " pseudo" + updatedUser.pseudo)
req.session.user.pseudo = updatedUser.pseudo; req.session.user.pseudo = updatedUser.pseudo;
console.log("req.session.user.pseudo" + req.session.user.pseudo) console.log("req.session.user.pseudo" + req.session.user.pseudo)
@ -136,7 +136,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if (!user) { if (!user) {
res.status(200).json({ error: "true", message: 'User not found' }); res.status(200).json({ error: "true", message: 'User not found' });
return; return;
@ -161,7 +161,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if (!user) { if (!user) {
res.status(200).json({ error: "true", message: 'User not found' }); res.status(200).json({ error: "true", message: 'User not found' });
return; return;
@ -188,7 +188,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if (!user) { if (!user) {
res.status(200).json({ error: "true", message: 'User not found' }); res.status(200).json({ error: "true", message: 'User not found' });
return; return;
@ -213,7 +213,7 @@ class SessionController {
try{ try{
await db.connect(); await db.connect();
const [user, fields] = await db.getUserByPseudo(req.body.pseudo); const user = await db.getUserByPseudo(req.body.pseudo);
if (!user) { if (!user) {
res.status(200).json({ error: "true", message: 'User not found' }); res.status(200).json({ error: "true", message: 'User not found' });
return; return;

@ -111,30 +111,24 @@ class DatabaseService {
// Récupère l'utilisateur par son id // Récupère l'utilisateur par son id
async getUserByID(id){ async getUserByID(id){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT * FROM users WHERE idUser = ?', [id], (err, result) => { const [rows] = await this.client.promise().query('SELECT * FROM users WHERE idUser = ?', [id])
if(err){ console.log('Rows:', rows);
reject(err); return rows;
} } catch (err) {
else{ throw new Error(`Error fetching users: ${err.message}`);
resolve(result); }
}
});
});
} }
// Récupère l'utilisateur par son pseudo // Récupère l'utilisateur par son pseudo
async getUserByPseudo(pseudo){ async getUserByPseudo(pseudo){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT * FROM users WHERE pseudo = ?', [pseudo], (err, result) => { const [rows] = await this.client.promise().query('SELECT * FROM users WHERE pseudo = ?', [pseudo])
if(err){ console.log('Rows:', rows);
reject(err); return rows;
} } catch (err) {
else{ throw new Error(`Error fetching users: ${err.message}`);
resolve(result); }
}
});
});
} }
async getUsers(){ async getUsers(){
@ -159,55 +153,44 @@ class DatabaseService {
// insère un utilisateur dans la base de données // insère un utilisateur dans la base de données
async insertUser(user) { async insertUser(user) {
return new Promise((resolve, reject) => { try {
const { pseudo, password } = user; const { pseudo, password } = user;
this.client.query('INSERT INTO users (pseudo, password) VALUES (?, ?)', [pseudo, password], (err, result) => { const [rows] = await this.client.promise().query('INSERT INTO users (pseudo, password) VALUES (?, ?)', [pseudo, password])
if (err) { console.log('Rows:', rows);
reject(err); return rows;
} else { } catch (err) {
resolve(result); throw new Error(`Error fetching users: ${err.message}`);
} }
});
});
} }
async deleteUser(userId){ async deleteUser(userId){
return new Promise((resolve, reject) => { try {
this.client.query('DELETE FROM users WHERE idUser=?', [userId], (err, result) => { const [rows] = await this.client.promise().query('DELETE FROM users WHERE idUser=?', [userId])
if(err){ console.log('Rows:', rows);
reject(err); return rows;
} } catch (err) {
else{ throw new Error(`Error fetching users: ${err.message}`);
resolve(result); }
}
});
});
} }
async updatePseudo(userId, newPseudo){ async updatePseudo(userId, newPseudo){
return new Promise((resolve, reject) => { try {
this.client.query('UPDATE users SET pseudo = ? WHERE idUser = ?', [newPseudo, userId], (err, result) => { const [rows] = await this.client.promise().query('UPDATE users SET pseudo = ? WHERE idUser = ?', [newPseudo, userId])
if(err){ console.log('Rows:', rows);
reject(err); return rows;
} } catch (err) {
else{ throw new Error(`Error fetching users: ${err.message}`);
resolve(result); }
}
});
});
} }
async updatePassword(userId, newPassword){ async updatePassword(userId, newPassword){
return new Promise((resolve, reject) => { try {
this.client.query('UPDATE users SET password = ? WHERE idUser = ?', [newPassword, userId], (err, result) => { const [rows] = await this.client.promise().query('UPDATE users SET password = ? WHERE idUser = ?', [newPassword, userId])
if(err){ console.log('Rows:', rows);
reject(err); return rows;
} } catch (err) {
else{ throw new Error(`Error fetching users: ${err.message}`);
resolve(result); }
}
});
});
} }
// --------------------------------------------------------------- // ---------------------------------------------------------------
@ -215,61 +198,39 @@ class DatabaseService {
// --------------------------------------------------------------- // ---------------------------------------------------------------
async getDailyMastermindStats() { async getDailyMastermindStats() {
return new Promise((resolve, reject) => { try {
// Obtenez la date actuelle au format AAAA-MM-JJ
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const [rows] = await this.client.promise().query('SELECT pseudo, score FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? ORDER BY score ASC LIMIT 10',
// Récupérer les 5 meilleurs scores de la journée ["mastermind",
this.client.query( currentDate])
'SELECT pseudo, score FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? ORDER BY score ASC LIMIT 10', return rows;
["mastermind", } catch (err) {
currentDate], throw new Error(`Error fetching users: ${err.message}`);
(err, result) => { }
if (err) {
reject(err);
} else {
resolve(result);
}
}
);
});
} }
async getDailyEnigmaStats(enigmaLevel) { async getDailyEnigmaStats(enigmaLevel) {
return new Promise((resolve, reject) => { try {
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const [rows] = await this.client.promise().query('SELECT pseudo, time FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? ORDER BY time ASC LIMIT 10',
this.client.query( [enigmaLevel,
'SELECT pseudo, time FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? ORDER BY time ASC LIMIT 10', currentDate])
[enigmaLevel, return rows;
currentDate], } catch (err) {
(err, result) => { throw new Error(`Error fetching users: ${err.message}`);
if (err) { }
reject(err);
} else {
resolve(result);
}
}
);
});
} }
async getDailyOnlineStats() { async getDailyOnlineStats() {
return new Promise((resolve, reject) => { try {
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const [rows] = await this.client.promise().query('SELECT pseudo, COUNT(*) AS wins FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? AND win = ? GROUP BY users.idUser ORDER BY wins ASC LIMIT 10',
["multijoueur", currentDate, 1])
return rows;
} catch (err) {
throw new Error(`Error fetching users: ${err.message}`);
}
this.client.query(
'SELECT pseudo, COUNT(*) AS wins FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) = ? AND win = ? GROUP BY users.idUser ORDER BY wins ASC LIMIT 10',
["multijoueur", currentDate, 1],
(err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
}
);
});
} }
@ -278,77 +239,57 @@ class DatabaseService {
// --------------------------------------------------------------- // ---------------------------------------------------------------
async getWeeklyMastermindStats() { async getWeeklyMastermindStats() {
return new Promise((resolve, reject) => { try {
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const currentDay = new Date().getDay(); const currentDay = new Date().getDay();
const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10); const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10);
const [rows] = await this.client.promise().query('SELECT pseudo, score FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? ORDER BY score ASC LIMIT 10',
this.client.query( ["mastermind",
'SELECT pseudo, score FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? ORDER BY score ASC LIMIT 10', firstDayOfWeek,
["mastermind", currentDate])
firstDayOfWeek, return rows;
currentDate], } catch (err) {
(err, result) => { throw new Error(`Error fetching users: ${err.message}`);
if (err) { }
reject(err);
} else {
resolve(result);
}
}
);
});
} }
async getWeeklyEnigmaStats(enigmaLevel) { async getWeeklyEnigmaStats(enigmaLevel) {
return new Promise((resolve, reject) => { try {
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const currentDay = new Date().getDay(); const currentDay = new Date().getDay();
const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10); const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10);
const [rows] = await this.client.promise().query('SELECT pseudo, time FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? ORDER BY time ASC LIMIT 10',
this.client.query( [enigmaLevel,
'SELECT pseudo, time FROM users INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? ORDER BY time ASC LIMIT 10', firstDayOfWeek,
[enigmaLevel, currentDate])
firstDayOfWeek, return rows;
currentDate], } catch (err) {
(err, result) => { throw new Error(`Error fetching users: ${err.message}`);
if (err) { }
reject(err);
} else {
resolve(result);
}
}
);
});
} }
async getWeeklyOnlineStats() { async getWeeklyOnlineStats() {
return new Promise((resolve, reject) => { try {
const currentDate = new Date().toISOString().slice(0, 10); const currentDate = new Date().toISOString().slice(0, 10);
const currentDay = new Date().getDay(); const currentDay = new Date().getDay();
const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10); const firstDayOfWeek = new Date(new Date().setDate(new Date().getDate() - currentDay)).toISOString().slice(0, 10);
const [rows] = await this.client.promise().query(`
this.client.query(` SELECT users.pseudo, COUNT(*) as wins
SELECT users.pseudo, COUNT(*) as wins FROM users
FROM users INNER JOIN games ON users.idUser = games.idUser
INNER JOIN games ON users.idUser = games.idUser WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? AND win = ?
WHERE gameType = ? AND SUBSTR(playedDate, 1, 10) BETWEEN ? AND ? AND win = ? GROUP BY users.pseudo
GROUP BY users.pseudo ORDER BY wins ASC
ORDER BY wins ASC LIMIT 10;
LIMIT 10; `,
`, ["multijoueur",
["multijoueur", firstDayOfWeek,
firstDayOfWeek, currentDate,
currentDate, 1])
1], return rows;
(err, result) => { } catch (err) {
if (err) { throw new Error(`Error fetching users: ${err.message}`);
reject(err); }
} else {
resolve(result);
}
}
);
});
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
@ -356,98 +297,69 @@ class DatabaseService {
// ------------------------------------------------------------- // -------------------------------------------------------------
async getNbGamesMastermindByUserId(userId){ async getNbGamesMastermindByUserId(userId){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"], (err, result) => { const [rows] = await this.client.promise().query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getBestScoreMastermindByUserId(userId){ async getBestScoreMastermindByUserId(userId){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT MIN(score) AS bestScore FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"], (err, result) => { const [rows] = await this.client.promise().query('SELECT MIN(score) AS bestScore FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getAvgNbTryMastermindByUserId(userId){ async getAvgNbTryMastermindByUserId(userId){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT AVG(score) AS avgNbTry FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"], (err, result) => { const [rows] = await this.client.promise().query('SELECT AVG(score) AS avgNbTry FROM games WHERE idUser = ? AND gameType = ?', [userId, "mastermind"])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async addMastermindStats(userId, score, time){ async addMastermindStats(userId, score, time){
return new Promise((resolve, reject) => { try {
this.client.query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, "mastermind", 1, score, time], (err, result) => { const [rows] = await this.client.promise().query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, "mastermind", 1, score, time])
if(err){ return rows;
console.log(err) } catch (err) {
reject(err); throw new Error(`Error fetching users: ${err.message}`);
} }
else{
resolve(result);
}
});
});
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
// ------------------- STATS EN LIGNE -------------------------- // ------------------- STATS EN LIGNE --------------------------
// ------------------------------------------------------------- // -------------------------------------------------------------
async getNbGamesOnlineByUserId(userId){ async getNbGamesOnlineByUserId(userId){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, "multijoueur"], (err, result) => { const [rows] = await this.client.promise().query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, "multijoueur"])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getNbWinsOnlineByUserId(userId){ async getNbWinsOnlineByUserId(userId){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT COUNT(*) AS nbWins FROM games WHERE idUser = ? AND gameType = ? AND win = ?', [userId, "multijoueur", 1], (err, result) => { const [rows] = await this.client.promise().query('SELECT COUNT(*) AS nbWins FROM games WHERE idUser = ? AND gameType = ? AND win = ?', [userId, "multijoueur", 1])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async addOnlineStats(userId, win, time){ async addOnlineStats(userId, win, time){
return new Promise((resolve, reject) => { try {
this.client.query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, "multijoueur", win, 0, time], (err, result) => { const [rows] = await this.client.promise().query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, "multijoueur", win, 0, time])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
@ -455,109 +367,77 @@ class DatabaseService {
// ------------------------------------------------------------- // -------------------------------------------------------------
async getNbGamesEnigmeByUserId(userId, enigmaLevel){ async getNbGamesEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel], (err, result) => { const [rows] = await this.client.promise().query('SELECT COUNT(*) AS nbGames FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getNbWinsEnigmeByUserId(userId, enigmaLevel){ async getNbWinsEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT COUNT(*) AS nbWins FROM games WHERE idUser = ? AND gameType = ? AND win = ?', [userId, enigmaLevel, 1], (err, result) => { const [rows] = await this.client.promise().query('SELECT COUNT(*) AS nbWins FROM games WHERE idUser = ? AND gameType = ? AND win = ?', [userId, enigmaLevel, 1])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getBestScoreEnigmeByUserId(userId, enigmaLevel){ async getBestScoreEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT MAX(score) AS bestScore FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel], (err, result) => { const [rows] = await this.client.promise().query('SELECT MAX(score) AS bestScore FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getAvgScoreEnigmeByUserId(userId, enigmaLevel){ async getAvgScoreEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT AVG(score) AS avgScore FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel], (err, result) => { const [rows] = await this.client.promise().query('SELECT AVG(score) AS avgScore FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getBestTimeEnigmeByUserId(userId, enigmaLevel){ async getBestTimeEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT MIN(time) AS bestTime FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel], (err, result) => { const [rows] = await this.client.promise().query('SELECT MIN(time) AS bestTime FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async getAvgTimeEnigmeByUserId(userId, enigmaLevel){ async getAvgTimeEnigmeByUserId(userId, enigmaLevel){
return new Promise((resolve, reject) => { try {
this.client.query('SELECT AVG(time) AS avgTime FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel], (err, result) => { const [rows] = await this.client.promise().query('SELECT AVG(time) AS avgTime FROM games WHERE idUser = ? AND gameType = ?', [userId, enigmaLevel])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
async addEasyEnigmaStats(userId, enigmaLevel, win, time){ async addEasyEnigmaStats(userId, enigmaLevel, win, time){
return new Promise((resolve, reject) => { try {
this.client.query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, enigmaLevel, win, 0, time], (err, result) => { const [rows] = await this.client.promise().query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, enigmaLevel, win, 0, time])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
// async addMediumEnigmaStats(userId, enigmaLevel, score) // async addMediumEnigmaStats(userId, enigmaLevel, score)
async addHardEnigmaStats(userId, enigmaLevel, win, time){ async addHardEnigmaStats(userId, enigmaLevel, win, time){
return new Promise((resolve, reject) => { try {
this.client.query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, enigmaLevel, win, 0, time], (err, result) => { const [rows] = await this.client.promise().query('INSERT INTO games (idUser, gameType, win, score, time) VALUES (?, ?, ?, ?, ?)', [userId, enigmaLevel, win, 0, time])
if(err){ return rows;
reject(err); } catch (err) {
} throw new Error(`Error fetching users: ${err.message}`);
else{ }
resolve(result);
}
});
});
} }
} }

Loading…
Cancel
Save