From ebdfcb1bff9070c54291303193fa2736897279b7 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Tue, 14 May 2024 16:32:55 +0200 Subject: [PATCH 01/13] Integration bd sqlite3 --- package.json | 8 ++++--- src/database.ts | 57 ++++++++++++++++++++++++++++++++++++++++++++++ src/db/database.db | 0 3 files changed, 62 insertions(+), 3 deletions(-) create mode 100644 src/database.ts create mode 100644 src/db/database.db diff --git a/package.json b/package.json index abda9a9..2a045ad 100644 --- a/package.json +++ b/package.json @@ -4,12 +4,13 @@ "type": "module", "scripts": { "build": "tsc", - "start": "tsx src/server.ts" + "start": "tsx src/server.ts", + "mamanColin": "tsx src/database.ts" }, "devDependencies": { + "@types/bun": "^1.0.4", "tsx": "^4.7.0", - "typescript": "^5.3.3", - "@types/bun": "^1.0.4" + "typescript": "^5.3.3" }, "dependencies": { "@fastify/cors": "^9.0.0", @@ -17,6 +18,7 @@ "@sinclair/typebox": "^0.32.9", "fastify": "^4.25.2", "nanoid": "^5.0.4", + "sqlite3": "^5.1.7", "zeromq": "6.0.0-beta.19" } } diff --git a/src/database.ts b/src/database.ts new file mode 100644 index 0000000..8b42b8e --- /dev/null +++ b/src/database.ts @@ -0,0 +1,57 @@ +import sqlite3 from "sqlite3"; + +let db = new sqlite3.Database( + "./db/database.db", + sqlite3.OPEN_READWRITE, + (err: Error | null) => { + if (err) console.error(err.message); + } +); + +db.close((err) => { + if (err) { + console.error(err.message); + } + console.log("Close the database connection."); +}); + +// // Création de la table registered_user dans la base de données + +// const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; + +// // Exécution de la requête pour créer la table +// db.run(tableRegisteredUser, [], function (err) { +// if (err) { +// return console.error(err.message); +// } +// console.log("Table créée avec succès"); +// }); + +// // Insertion d'un utilisateur dans la table registered_user + +// const insertUser = `INSERT INTO registered_user (login, password, permissions) VALUES ('admin', 'admin', 1)`; + +// // Exécution de la requête pour insérer un utilisateur +// db.run(insertUser, [], function (err) { +// if (err) { +// return console.error(err.message); +// } +// console.log(`Utilisateur inséré avec succès`); +// }); + +// // SELECT de tous les utilisateurs de la table registered_user + +// const selectAllUsers = `SELECT * FROM registered_user`; + +// // Exécution de la requête pour sélectionner tous les utilisateurs + +// db.all(selectAllUsers, [], (err, rows) => { +// if (err) { +// throw err; +// } +// rows.forEach((row) => { +// console.log(row); +// }); +// }); + +// db.close(); diff --git a/src/db/database.db b/src/db/database.db new file mode 100644 index 0000000..e69de29 -- 2.36.3 From 20d15ce6d6485a89369c89711ebe274e70819697 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Tue, 14 May 2024 16:42:02 +0200 Subject: [PATCH 02/13] Creation de la table + ajout user --- db/database.db | Bin 0 -> 16384 bytes package.json | 2 +- src/database.ts | 84 ++++++++++++++++++++++++++---------------------- 3 files changed, 47 insertions(+), 39 deletions(-) create mode 100644 db/database.db diff --git a/db/database.db b/db/database.db new file mode 100644 index 0000000000000000000000000000000000000000..b1adfb663fae42d6f46bf54352f17fd7c75038c3 GIT binary patch literal 16384 zcmeI(!A`<37zgl{A%Y3ac-gf_$cTyYY~nPHA&voKByw7&RI&s%T}Sk)58(s&7QT@O z5|4Vc4A3~^3*f)$x32B_W&Pc@W&NHVrh;9^$uvmWA=xFAl4HgQAq5ph73)IPNxr|H z`>QRG{p7i-e-N$qL~5`4i)v6H009U<00Izz00bZa0SG_<0xN;8Rx(VJ4%6UrBINBv zJ)-(j+|ERFmG2f$U2b`tdDe-|S?=0;6ih`^t!z9vbbFEVv7hBk#5k0xNW{pWNs;8b zg&#R{ldK*t7qOP(@iXqSuG?x`?vS1HA+rWvr{$>iZSHtYHi^e!#5{iCF{h(qVB1Z0 z6G(X%C!=5EBAJF#hH)gna(}NHIIZ4*vwD`Y(KsrUjGjqJ7>&gJYTLmqjkCU=yJ!C( zH=rr#@&dc6g6eNXRTKz700Izz00bZa0SG_<0uX=z1U5rJr(47@D#2(PM%iIU?ThN~ zL{$_BKmY;|fB*y_009U<00Izz00cHmpscN40xZA(&xt { if (err) console.error(err.message); } ); -db.close((err) => { +// Création de la table registered_user dans la base de données + +const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; + +// Exécution de la requête pour créer la table +db.run(tableRegisteredUser, [], function (err) { if (err) { - console.error(err.message); + return console.error(err.message); } - console.log("Close the database connection."); + console.log("Table créée avec succès"); }); -// // Création de la table registered_user dans la base de données +// Insertion d'un utilisateur dans la table registered_user -// const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; +const insertUser = `INSERT INTO registered_user (login, password, permissions) VALUES ('admin', 'admin', 1)`; -// // Exécution de la requête pour créer la table -// db.run(tableRegisteredUser, [], function (err) { -// if (err) { -// return console.error(err.message); -// } -// console.log("Table créée avec succès"); -// }); - -// // Insertion d'un utilisateur dans la table registered_user - -// const insertUser = `INSERT INTO registered_user (login, password, permissions) VALUES ('admin', 'admin', 1)`; - -// // Exécution de la requête pour insérer un utilisateur -// db.run(insertUser, [], function (err) { -// if (err) { -// return console.error(err.message); -// } -// console.log(`Utilisateur inséré avec succès`); -// }); +// Exécution de la requête pour insérer un utilisateur +db.run(insertUser, [], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Utilisateur inséré avec succès`); +}); -// // SELECT de tous les utilisateurs de la table registered_user +// SELECT de tous les utilisateurs de la table registered_user -// const selectAllUsers = `SELECT * FROM registered_user`; +const selectAllUsers = `SELECT * FROM registered_user`; -// // Exécution de la requête pour sélectionner tous les utilisateurs +// Exécution de la requête pour sélectionner tous les utilisateurs -// db.all(selectAllUsers, [], (err, rows) => { -// if (err) { -// throw err; -// } -// rows.forEach((row) => { -// console.log(row); -// }); -// }); +db.all(selectAllUsers, [], (err, rows) => { + if (err) { + throw err; + } + rows.forEach((row) => { + console.log(row); + }); +}); -// db.close(); +// Fermeture de la base de données +db.close((err) => { + if (err) { + console.error(err.message); + } + console.log("Close the database connection."); +}); -- 2.36.3 From 72649cf58a7d7914065c52e1533281706232162c Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Tue, 14 May 2024 20:16:07 +0200 Subject: [PATCH 03/13] utilisation de fonction (create, insert, update, delete) --- db/database.db | Bin 16384 -> 16384 bytes package.json | 2 +- src/database.ts | 194 +++++++++++++++++++++++++++++++++++++----------- 3 files changed, 150 insertions(+), 46 deletions(-) diff --git a/db/database.db b/db/database.db index b1adfb663fae42d6f46bf54352f17fd7c75038c3..2392cd668b8ac49fd72fdd484abb623f1d75b298 100644 GIT binary patch delta 146 zcmZo@U~Fh$oFL7}HBrWyk!xeZ5`GQ_0R{&C*Zj9O3ksa$Hxg!IWe}I=EG7r7+~J=Xz$wko$jTrt&Y75!o0$hD zxEL5182P_5@PCJ>nII_4!3 Dkk%n! diff --git a/package.json b/package.json index 182ea77..db2a021 100644 --- a/package.json +++ b/package.json @@ -5,7 +5,7 @@ "scripts": { "build": "tsc", "start": "tsx src/server.ts", - "dbb": "tsx src/database.ts" + "db": "tsx src/database.ts" }, "devDependencies": { "@types/bun": "^1.0.4", diff --git a/src/database.ts b/src/database.ts index d4b3eb7..b3654f9 100644 --- a/src/database.ts +++ b/src/database.ts @@ -1,65 +1,169 @@ import sqlite3 from "sqlite3"; import fs from "fs"; +import { sleep } from "bun"; + const dbDirectory = "./db"; const dbFilePath = `${dbDirectory}/database.db`; // Créer le répertoire db s'il n'existe pas -if (!fs.existsSync(dbDirectory)) { - fs.mkdirSync(dbDirectory); +function createDbDirectory() { + if (!fs.existsSync(dbDirectory)) { + fs.mkdirSync(dbDirectory); + } } -// Ouverture de la base de données -let db = new sqlite3.Database( - dbFilePath, - sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, - (err: Error | null) => { - if (err) console.error(err.message); - } -); +// Ouvrir la base de données +function openDatabase() { + return new sqlite3.Database( + dbFilePath, + sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, + (err: Error | null) => { + if (err) console.error(err.message); + } + ); +} -// Création de la table registered_user dans la base de données +// Créer la table registered_user dans la base de données +function createRegisteredUserTable(db: sqlite3.Database) { + const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; -const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; + db.run(tableRegisteredUser, [], function (err) { + if (err) { + return console.error(err.message); + } + console.log("Table créée avec succès"); + }); +} -// Exécution de la requête pour créer la table -db.run(tableRegisteredUser, [], function (err) { - if (err) { - return console.error(err.message); - } - console.log("Table créée avec succès"); -}); +// Insérer un utilisateur dans la table registered_user +function insertUser( + db: sqlite3.Database, + login: string, + password: string, + permissions: number +) { + const insertUserQuery = `INSERT INTO registered_user (login, password, permissions) VALUES (?, ?, ?)`; -// Insertion d'un utilisateur dans la table registered_user + db.run(insertUserQuery, [login, password, permissions], function (err) { + if (err) { + return console.error(err.message); + } + console.log( + `Utilisateur inséré avec succès. ID utilisateur: ${this.lastID}` + ); + }); +} -const insertUser = `INSERT INTO registered_user (login, password, permissions) VALUES ('admin', 'admin', 1)`; +// Modifier le login d'un utilisateur dans la table registered_user +function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) { + const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; -// Exécution de la requête pour insérer un utilisateur -db.run(insertUser, [], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Utilisateur inséré avec succès`); -}); + db.run(updateUserLoginQuery, [newLogin, id], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Login de l'utilisateur mis à jour avec succès.`); + }); +} -// SELECT de tous les utilisateurs de la table registered_user +// Modifier le mot de passe d'un utilisateur dans la table registered_user +function updateUserPassword( + db: sqlite3.Database, + id: number, + newPassword: string +) { + const updateUserPasswordQuery = `UPDATE registered_user SET password = ? WHERE id_user = ?`; -const selectAllUsers = `SELECT * FROM registered_user`; + db.run(updateUserPasswordQuery, [newPassword, id], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Mot de passe de l'utilisateur mis à jour avec succès.`); + }); +} -// Exécution de la requête pour sélectionner tous les utilisateurs +function updateUserPermissions( + db: sqlite3.Database, + id: number, + newPermissions: number +) { + const updateUserPermissionsQuery = `UPDATE registered_user SET permissions = ? WHERE id_user = ?`; -db.all(selectAllUsers, [], (err, rows) => { - if (err) { - throw err; - } - rows.forEach((row) => { - console.log(row); + db.run(updateUserPermissionsQuery, [newPermissions, id], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Permissions de l'utilisateur mises à jour avec succès.`); }); -}); +} -// Fermeture de la base de données -db.close((err) => { - if (err) { - console.error(err.message); - } - console.log("Close the database connection."); -}); +// Supprimer un utilisateur de la table registered_user +function deleteUser(db: sqlite3.Database, id: number) { + const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`; + + db.run(deleteUserQuery, [id], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Utilisateur supprimé avec succès.`); + }); +} + +// Supprimer tous les utilisateurs de la table registered_user +function deleteAllUsers(db: sqlite3.Database) { + const deleteAllUsersQuery = `DELETE FROM registered_user`; + + db.run(deleteAllUsersQuery, [], function (err) { + if (err) { + return console.error(err.message); + } + console.log(`Tous les utilisateurs ont été supprimés avec succès.`); + }); +} + +// Sélectionner tous les utilisateurs de la table registered_user +function selectAllUsers(db: sqlite3.Database) { + const selectAllUsersQuery = `SELECT * FROM registered_user`; + + db.all(selectAllUsersQuery, [], (err, rows) => { + if (err) { + throw err; + } + rows.forEach((row) => { + console.log(row); + }); + }); +} + +// Fermer la base de données +function closeDatabase(db: sqlite3.Database) { + db.close((err) => { + if (err) { + console.error(err.message); + } + console.log("Fermeture de la connexion à la base de données."); + }); +} + +// Utilisation des fonctions +createDbDirectory(); +const db = openDatabase(); + +createRegisteredUserTable(db); +deleteAllUsers(db); + +insertUser(db, "user1", "password1", 1); + +selectAllUsers(db); + +updateUserLogin(db, 1, "newUser1"); +updateUserPassword(db, 1, "newPassword1"); +updateUserPermissions(db, 1, 2); + +selectAllUsers(db); + +deleteUser(db, 1); + +selectAllUsers(db); + +closeDatabase(db); -- 2.36.3 From b62e80e5383ded2658d802ab8f81508e6fbc46fe Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Wed, 15 May 2024 10:57:17 +0200 Subject: [PATCH 04/13] fin de redaction des fonction pour la table user avant creation de l'api --- db/database.db | Bin 16384 -> 16384 bytes src/database.ts | 77 ++++++++++++++++++++++++++++++------------------ 2 files changed, 49 insertions(+), 28 deletions(-) diff --git a/db/database.db b/db/database.db index 2392cd668b8ac49fd72fdd484abb623f1d75b298..5c8fb793af91f8d6330ed289ae6700faff526fff 100644 GIT binary patch delta 120 zcmZo@U~Fh$oFL68JyFJ)QF>#-5`GRw{?`orule6^78E$dFE7B&${;DunV6EBnP&th z85kJ&MMXJEi&Kk)c_+V>7YFM2#=!rL|LtZ$g=_qBT+EV;5arw)%%Y4Sbv&HR;$Vg$ L?We}I=EG { + if (err) { + console.error(err.message); + } + console.log("Fermeture de la connexion à la base de données."); + }); +} + +/////////////////////////// Gestion des utilisateurs /////////////////////////// +// CREATE TABLE registered_user ( +// id_user SERIAL PRIMARY KEY, +// login VARCHAR(64) NOT NULL, +// password VARCHAR(72) NOT NULL, +// permissions INT NOT NULL, +// UNIQUE (login) +// ); + // Créer la table registered_user dans la base de données function createRegisteredUserTable(db: sqlite3.Database) { const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; @@ -57,7 +76,6 @@ function insertUser( // Modifier le login d'un utilisateur dans la table registered_user function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) { const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; - db.run(updateUserLoginQuery, [newLogin, id], function (err) { if (err) { return console.error(err.message); @@ -124,8 +142,8 @@ function deleteAllUsers(db: sqlite3.Database) { // Sélectionner tous les utilisateurs de la table registered_user function selectAllUsers(db: sqlite3.Database) { const selectAllUsersQuery = `SELECT * FROM registered_user`; - db.all(selectAllUsersQuery, [], (err, rows) => { + console.log("Tous les utilisateurs enregistrés :"); if (err) { throw err; } @@ -135,35 +153,38 @@ function selectAllUsers(db: sqlite3.Database) { }); } -// Fermer la base de données -function closeDatabase(db: sqlite3.Database) { - db.close((err) => { +// Sélectionner un utilisateur par son login +function selectUserByLogin(db: sqlite3.Database, login: string) { + const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`; + + db.get(selectUserByLoginQuery, [login], (err, row) => { + console.log("Utilisateur avec le login, " + login + " :"); if (err) { - console.error(err.message); + return console.error(err.message); } - console.log("Fermeture de la connexion à la base de données."); + console.log(row); }); } -// Utilisation des fonctions -createDbDirectory(); -const db = openDatabase(); - -createRegisteredUserTable(db); -deleteAllUsers(db); - -insertUser(db, "user1", "password1", 1); - -selectAllUsers(db); - -updateUserLogin(db, 1, "newUser1"); -updateUserPassword(db, 1, "newPassword1"); -updateUserPermissions(db, 1, 2); +// Sélectionner un utilisateur par son ID +function selectUserById(db: sqlite3.Database, id: number) { + const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`; -selectAllUsers(db); - -deleteUser(db, 1); - -selectAllUsers(db); + db.get(selectUserByIdQuery, [id], (err, row) => { + console.log("Utilisateur avec l'ID, " + id + " :"); + if (err) { + return console.error(err.message); + } + console.log(row); + }); +} -closeDatabase(db); +/////////////////////////// Exécution des requêtes /////////////////////////// +const db = openDatabase(); +db.serialize(() => { + createDbDirectory(); + createRegisteredUserTable(db); + insertUser(db, "user1", "password1", 1); + selectAllUsers(db); + closeDatabase(db); +}); -- 2.36.3 From 9fcc8a806cdfbf7b132d64916e1e9aa37f2da052 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Wed, 15 May 2024 11:45:56 +0200 Subject: [PATCH 05/13] api fonctionnelle pour action sur la table user --- package.json | 3 +- src/database.ts | 25 +++--- src/server.ts | 198 ++++++++++++++++++++++++++++++++++++++---------- 3 files changed, 178 insertions(+), 48 deletions(-) diff --git a/package.json b/package.json index db2a021..dbeb388 100644 --- a/package.json +++ b/package.json @@ -16,7 +16,8 @@ "@fastify/cors": "^9.0.0", "@fastify/type-provider-typebox": "^4.0.0", "@sinclair/typebox": "^0.32.9", - "fastify": "^4.25.2", + "fastify": "^4.27.0", + "fastify-sqlite-typed": "^0.1.1", "nanoid": "^5.0.4", "sqlite3": "^5.1.7", "zeromq": "6.0.0-beta.19" diff --git a/src/database.ts b/src/database.ts index bac6eb5..87264df 100644 --- a/src/database.ts +++ b/src/database.ts @@ -179,12 +179,19 @@ function selectUserById(db: sqlite3.Database, id: number) { }); } -/////////////////////////// Exécution des requêtes /////////////////////////// -const db = openDatabase(); -db.serialize(() => { - createDbDirectory(); - createRegisteredUserTable(db); - insertUser(db, "user1", "password1", 1); - selectAllUsers(db); - closeDatabase(db); -}); +/////////////////////////// Export des fonctions /////////////////////////// +export { + createDbDirectory, + openDatabase, + closeDatabase, + createRegisteredUserTable, + insertUser, + updateUserLogin, + updateUserPassword, + updateUserPermissions, + deleteUser, + deleteAllUsers, + selectAllUsers, + selectUserByLogin, + selectUserById, +}; diff --git a/src/server.ts b/src/server.ts index 20a926b..379bc19 100644 --- a/src/server.ts +++ b/src/server.ts @@ -1,9 +1,25 @@ -import cors from '@fastify/cors'; -import { Type, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'; -import Fastify, { FastifyReply } from 'fastify'; -import { nanoid } from 'nanoid'; -import { allocateBuffer, IMAGES } from 'runner'; -import { Pull, Push } from 'zeromq'; +import cors from "@fastify/cors"; +import { Type, TypeBoxTypeProvider } from "@fastify/type-provider-typebox"; +import Fastify, { FastifyReply, FastifyRequest } from "fastify"; +import { nanoid } from "nanoid"; +import { allocateBuffer, IMAGES } from "runner"; +import { Pull, Push } from "zeromq"; + +import { + createDbDirectory, + openDatabase, + closeDatabase, + createRegisteredUserTable, + insertUser, + updateUserLogin, + updateUserPassword, + updateUserPermissions, + deleteUser, + deleteAllUsers, + selectAllUsers, + selectUserByLogin, + selectUserById, +} from "./database"; const sender = new Push(); await sender.bind(`tcp://127.0.0.1:5557`); @@ -17,37 +33,143 @@ const fastify = Fastify({ logger: true, }).withTypeProvider(); await fastify.register(cors, { - origin: process.env.ALLOW_ORIGIN || '*', + origin: process.env.ALLOW_ORIGIN || "*", }); -fastify.post('/run', { - schema: { - body: Type.Object({ - code: Type.String(), - language: Type.String(), - }), +// Code runner in a container + +// POST /run : Run code in a container + +fastify.post( + "/run", + { + schema: { + body: Type.Object({ + code: Type.String(), + language: Type.String(), + }), + }, }, -}, (req, reply) => { - const { code, language } = req.body; - const jobId = generateId(); - const buffer = allocateBuffer(jobId, code, IMAGES.moshell); - reply.raw.writeHead(200, { - 'Content-Type': 'text/event-stream', - Connection: 'keep-alive', - 'Cache-Control': 'no-cache', - 'Access-Control-Allow-Origin': process.env.ALLOW_ORIGIN || '*', - }); - reply.raw.on('close', () => { - delete clients[jobId]; - }); - sender.send(buffer).then(() => { - reply.raw.write('event: connected\n'); - reply.raw.write(`data: ${jobId}\n`); - reply.raw.write('id: 0\n\n'); - }); - clients[jobId] = reply; + (req, reply) => { + const { code, language } = req.body; + const jobId = generateId(); + const buffer = allocateBuffer(jobId, code, IMAGES.moshell); + reply.raw.writeHead(200, { + "Content-Type": "text/event-stream", + Connection: "keep-alive", + "Cache-Control": "no-cache", + "Access-Control-Allow-Origin": process.env.ALLOW_ORIGIN || "*", + }); + reply.raw.on("close", () => { + delete clients[jobId]; + }); + sender.send(buffer).then(() => { + reply.raw.write("event: connected\n"); + reply.raw.write(`data: ${jobId}\n`); + reply.raw.write("id: 0\n\n"); + }); + clients[jobId] = reply; + } +); + +// Database + +// Création du répertoire de la base de données s'il n'existe pas +createDbDirectory(); + +// Ouvrir la base de données +const db = openDatabase(); + +// Créer la table registered_user si elle n'existe pas +createRegisteredUserTable(db); + +// Route pour créer un utilisateur +fastify.post<{ + Body: { + login: string; + password: string; + permissions: number; + }; +}>("/users", async (request, reply) => { + const { login, password, permissions } = request.body; + insertUser(db, login, password, permissions); + reply.send({ success: true }); +}); + +// Route pour mettre à jour le login d'un utilisateur +fastify.put<{ + Params: { id: string }; + Body: { newLogin: string }; +}>("/users/:id/login", async (request, reply) => { + const { id } = request.params; + const { newLogin } = request.body; + updateUserLogin(db, parseInt(id), newLogin); + reply.send({ success: true }); +}); + +// Route pour mettre à jour le mot de passe d'un utilisateur +fastify.put<{ + Params: { id: string }; + Body: { newPassword: string }; +}>("/users/:id/password", async (request, reply) => { + const { id } = request.params; + const { newPassword } = request.body; + updateUserPassword(db, parseInt(id), newPassword); + reply.send({ success: true }); }); +// Route pour mettre à jour les permissions d'un utilisateur +fastify.put<{ + Params: { id: string }; + Body: { newPermissions: number }; +}>("/users/:id/permissions", async (request, reply) => { + const { id } = request.params; + const { newPermissions } = request.body; + updateUserPermissions(db, parseInt(id), newPermissions); + reply.send({ success: true }); +}); + +// Route pour supprimer un utilisateur +fastify.delete<{ + Params: { id: string }; +}>("/users/:id", async (request, reply) => { + const { id } = request.params; + deleteUser(db, parseInt(id)); + reply.send({ success: true }); +}); + +// Route pour supprimer tous les utilisateurs +fastify.delete("/users", async (request, reply) => { + deleteAllUsers(db); + reply.send({ success: true }); +}); + +// Route pour récupérer tous les utilisateurs +fastify.get("/users", async (request, reply) => { + const users = selectAllUsers(db); + return users; +}); + +// Route pour récupérer un utilisateur par son ID +fastify.get<{ + Params: { id: string }; +}>("/users/:id", async (request, reply) => { + const { id } = request.params; + const user = selectUserById(db, parseInt(id)); + return user; +}); + +// Route pour récupérer un utilisateur par son login +fastify.get<{ + Params: { login: string }; +}>("/users/login/:login", async (request, reply) => { + const { login } = request.params; + const user = selectUserByLogin(db, login); + return user; +}); + +// Forward output from the runner to the client + async function forwardOutput() { for await (const [buff] of receiver) { const messageType = buff.readInt8(); @@ -62,23 +184,23 @@ async function forwardOutput() { case 1: case 2: const text = encodeURIComponent(buff.subarray(33).toString()); - raw.write('event: message\n'); + raw.write("event: message\n"); if (messageType === 1) { - raw.write('id: stdout\n'); + raw.write("id: stdout\n"); } else { - raw.write('id: stderr\n'); + raw.write("id: stderr\n"); } raw.write(`data: ${text}\n\n`); break; case 3: const exitCode = buff.readUint32BE(33); - raw.write('event: message\n'); - raw.write('id: exit\n'); + raw.write("event: message\n"); + raw.write("id: exit\n"); raw.write(`data: ${exitCode}\n\n`); raw.end(); break; default: - console.error('Unknown message type', messageType); + console.error("Unknown message type", messageType); } } } -- 2.36.3 From 4fe64e0601efa8d3bcbbc284e12a0f9952d87899 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Thu, 16 May 2024 11:23:57 +0200 Subject: [PATCH 06/13] retour json fonctionnel --- package.json | 3 +-- src/database.ts | 67 +++++++++++++++++++++++++++++++++++++++++++------ src/server.ts | 9 +++---- 3 files changed, 64 insertions(+), 15 deletions(-) diff --git a/package.json b/package.json index dbeb388..23bfe2a 100644 --- a/package.json +++ b/package.json @@ -4,8 +4,7 @@ "type": "module", "scripts": { "build": "tsc", - "start": "tsx src/server.ts", - "db": "tsx src/database.ts" + "start": "tsx src/server.ts" }, "devDependencies": { "@types/bun": "^1.0.4", diff --git a/src/database.ts b/src/database.ts index 87264df..db7eaab 100644 --- a/src/database.ts +++ b/src/database.ts @@ -4,6 +4,54 @@ import fs from "fs"; const dbDirectory = "./db"; const dbFilePath = `${dbDirectory}/database.db`; +// Fonctions utilitaires pour les requêtes SQL + +function runDB( + db: sqlite3.Database, + query: string, + params: any[] +): Promise { + return new Promise((resolve, reject) => { + db.run(query, params, (err) => { + if (err) { + reject(err); + } else { + resolve(); + } + }); + }); +} + +function allDB(db: sqlite3.Database, query: string): Promise { + return new Promise((resolve, reject) => { + db.all(query, (err, rows) => { + if (err) { + reject(err); + } else { + resolve(rows); + } + }); + }); +} + +function getDB( + db: sqlite3.Database, + query: string, + params: any[] +): Promise { + return new Promise((resolve, reject) => { + db.get(query, params, (err, row) => { + if (err) { + reject(err); + } else { + resolve(); + } + }); + }); +} + +// Fonctions pour la gestion de la base de données + // Créer le répertoire db s'il n'existe pas function createDbDirectory() { if (!fs.existsSync(dbDirectory)) { @@ -140,15 +188,18 @@ function deleteAllUsers(db: sqlite3.Database) { } // Sélectionner tous les utilisateurs de la table registered_user -function selectAllUsers(db: sqlite3.Database) { +function selectAllUsers(db: sqlite3.Database): Promise { const selectAllUsersQuery = `SELECT * FROM registered_user`; - db.all(selectAllUsersQuery, [], (err, rows) => { - console.log("Tous les utilisateurs enregistrés :"); - if (err) { - throw err; - } - rows.forEach((row) => { - console.log(row); + + return new Promise((resolve, reject) => { + db.all(selectAllUsersQuery, (err, rows) => { + if (err) { + reject(err); + } else { + console.log("Utilisateurs :"); + console.log(rows); + resolve(rows); + } }); }); } diff --git a/src/server.ts b/src/server.ts index 379bc19..74d6958 100644 --- a/src/server.ts +++ b/src/server.ts @@ -143,11 +143,10 @@ fastify.delete("/users", async (request, reply) => { deleteAllUsers(db); reply.send({ success: true }); }); - // Route pour récupérer tous les utilisateurs fastify.get("/users", async (request, reply) => { - const users = selectAllUsers(db); - return users; + const users = await selectAllUsers(db); + reply.send(users); }); // Route pour récupérer un utilisateur par son ID @@ -156,7 +155,7 @@ fastify.get<{ }>("/users/:id", async (request, reply) => { const { id } = request.params; const user = selectUserById(db, parseInt(id)); - return user; + reply.send(user); }); // Route pour récupérer un utilisateur par son login @@ -165,7 +164,7 @@ fastify.get<{ }>("/users/login/:login", async (request, reply) => { const { login } = request.params; const user = selectUserByLogin(db, login); - return user; + reply.send(user); }); // Forward output from the runner to the client -- 2.36.3 From 7047c3d4d362f05f62f6145cf17e373610dba2b0 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Thu, 16 May 2024 11:47:30 +0200 Subject: [PATCH 07/13] action sur user avec retour promesse complet --- db/database.db | Bin 16384 -> 0 bytes src/database.ts | 86 ++++++++------------------------------------- src/db/database.db | Bin 0 -> 16384 bytes src/server.ts | 12 +++---- 4 files changed, 20 insertions(+), 78 deletions(-) delete mode 100644 db/database.db diff --git a/db/database.db b/db/database.db deleted file mode 100644 index 5c8fb793af91f8d6330ed289ae6700faff526fff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 16384 zcmeI(!Aiq07zgmg&bg^w1Q|sBsb4Q#w+&*o{_4@KRE;T;7_=TCEBtp5K=@UytpMq9BQT zsWta%sR=_v=VEMAcgmg#duFe3j0OP+KmY;|fB*y_009U<00Izzz+V?wT9_p(R^IIo zJ%1xP>J_tMF&A%gESs~$TFb}7+IS11Hm`4>?2WKD_VU-C4(o#e1Rwwb2tWV=5P$## zAOHafKwz4{ys<(*Hv|@PMv=y^|BHFUN(MD^^8J5WKIS0+0SG_<0uX=z1Rwwb2tWV= Q5co#|%hagQ)PDfx2h4<|egFUf diff --git a/src/database.ts b/src/database.ts index db7eaab..3f7da04 100644 --- a/src/database.ts +++ b/src/database.ts @@ -1,10 +1,10 @@ import sqlite3 from "sqlite3"; import fs from "fs"; -const dbDirectory = "./db"; +const dbDirectory = "./src/db"; const dbFilePath = `${dbDirectory}/database.db`; -// Fonctions utilitaires pour les requêtes SQL +// Fonctions pour exécuter des requêtes SQL sur la base de données SQLite avec des promesses pour gérer les erreurs et les résultats asynchrones function runDB( db: sqlite3.Database, @@ -91,15 +91,10 @@ function closeDatabase(db: sqlite3.Database) { // ); // Créer la table registered_user dans la base de données -function createRegisteredUserTable(db: sqlite3.Database) { +function createRegisteredUserTable(db: sqlite3.Database): Promise { const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; - db.run(tableRegisteredUser, [], function (err) { - if (err) { - return console.error(err.message); - } - console.log("Table créée avec succès"); - }); + return runDB(db, tableRegisteredUser, []); } // Insérer un utilisateur dans la table registered_user @@ -111,25 +106,14 @@ function insertUser( ) { const insertUserQuery = `INSERT INTO registered_user (login, password, permissions) VALUES (?, ?, ?)`; - db.run(insertUserQuery, [login, password, permissions], function (err) { - if (err) { - return console.error(err.message); - } - console.log( - `Utilisateur inséré avec succès. ID utilisateur: ${this.lastID}` - ); - }); + return runDB(db, insertUserQuery, [login, password, permissions]); } // Modifier le login d'un utilisateur dans la table registered_user function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) { const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; - db.run(updateUserLoginQuery, [newLogin, id], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Login de l'utilisateur mis à jour avec succès.`); - }); + + return runDB(db, updateUserLoginQuery, [newLogin, id]); } // Modifier le mot de passe d'un utilisateur dans la table registered_user @@ -140,12 +124,7 @@ function updateUserPassword( ) { const updateUserPasswordQuery = `UPDATE registered_user SET password = ? WHERE id_user = ?`; - db.run(updateUserPasswordQuery, [newPassword, id], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Mot de passe de l'utilisateur mis à jour avec succès.`); - }); + return runDB(db, updateUserPasswordQuery, [newPassword, id]); } function updateUserPermissions( @@ -155,79 +134,42 @@ function updateUserPermissions( ) { const updateUserPermissionsQuery = `UPDATE registered_user SET permissions = ? WHERE id_user = ?`; - db.run(updateUserPermissionsQuery, [newPermissions, id], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Permissions de l'utilisateur mises à jour avec succès.`); - }); + return runDB(db, updateUserPermissionsQuery, [newPermissions, id]); } // Supprimer un utilisateur de la table registered_user function deleteUser(db: sqlite3.Database, id: number) { const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`; - db.run(deleteUserQuery, [id], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Utilisateur supprimé avec succès.`); - }); + return runDB(db, deleteUserQuery, [id]); } // Supprimer tous les utilisateurs de la table registered_user function deleteAllUsers(db: sqlite3.Database) { const deleteAllUsersQuery = `DELETE FROM registered_user`; - db.run(deleteAllUsersQuery, [], function (err) { - if (err) { - return console.error(err.message); - } - console.log(`Tous les utilisateurs ont été supprimés avec succès.`); - }); + return runDB(db, deleteAllUsersQuery, []); } // Sélectionner tous les utilisateurs de la table registered_user function selectAllUsers(db: sqlite3.Database): Promise { const selectAllUsersQuery = `SELECT * FROM registered_user`; - return new Promise((resolve, reject) => { - db.all(selectAllUsersQuery, (err, rows) => { - if (err) { - reject(err); - } else { - console.log("Utilisateurs :"); - console.log(rows); - resolve(rows); - } - }); - }); + return allDB(db, selectAllUsersQuery); } // Sélectionner un utilisateur par son login function selectUserByLogin(db: sqlite3.Database, login: string) { const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`; - db.get(selectUserByLoginQuery, [login], (err, row) => { - console.log("Utilisateur avec le login, " + login + " :"); - if (err) { - return console.error(err.message); - } - console.log(row); - }); + return getDB(db, selectUserByLoginQuery, [login]); } // Sélectionner un utilisateur par son ID function selectUserById(db: sqlite3.Database, id: number) { const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`; - db.get(selectUserByIdQuery, [id], (err, row) => { - console.log("Utilisateur avec l'ID, " + id + " :"); - if (err) { - return console.error(err.message); - } - console.log(row); - }); + return getDB(db, selectUserByIdQuery, [id]); } /////////////////////////// Export des fonctions /////////////////////////// diff --git a/src/db/database.db b/src/db/database.db index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..05f44b14f689c6a10f68b5793f726f70695313a4 100644 GIT binary patch literal 16384 zcmeI%O-jQ+6bJB0TdD~C*me7sEh&Py7K}1TFiqQZ0(KRm9ZR51Y$ipwdI%5TExeIO zaOotricv36{sS}N&E!2YzhpCHGIpX&(ruD1!;Fqun;8Z>C1Q*jy4Q5yw!h--+J9Gr z9i}gh);p^xERSg+8JN zO0L#2zA1;bbB|ksld#SlPNjRhak!Lyo!NVIjlI0&)1;`G%6X(RnaWwPRx&Mxl^-=r zi`0!ilgM@jzu+E?JbPeyQ@Z3+vV1YLU7bJRuISSunMW}RekI5q>h3#EpYB4X?vr%( zYhI?yNU11^)mQEBEZ?=qKBsO`ve!GQ)H`F-U{O4i51Va=>nthap!CeaQE8&8q4#s_ zMn1Ij0Sy8WfB*y_009U<00Izz00bZafn60i$Tx=b|E|7X>("/users/:id/password", async (request, reply) => { const { id } = request.params; const { newPassword } = request.body; - updateUserPassword(db, parseInt(id), newPassword); + await updateUserPassword(db, parseInt(id), newPassword); reply.send({ success: true }); }); @@ -125,7 +125,7 @@ fastify.put<{ }>("/users/:id/permissions", async (request, reply) => { const { id } = request.params; const { newPermissions } = request.body; - updateUserPermissions(db, parseInt(id), newPermissions); + await updateUserPermissions(db, parseInt(id), newPermissions); reply.send({ success: true }); }); @@ -134,13 +134,13 @@ fastify.delete<{ Params: { id: string }; }>("/users/:id", async (request, reply) => { const { id } = request.params; - deleteUser(db, parseInt(id)); + await deleteUser(db, parseInt(id)); reply.send({ success: true }); }); // Route pour supprimer tous les utilisateurs fastify.delete("/users", async (request, reply) => { - deleteAllUsers(db); + await deleteAllUsers(db); reply.send({ success: true }); }); // Route pour récupérer tous les utilisateurs @@ -154,7 +154,7 @@ fastify.get<{ Params: { id: string }; }>("/users/:id", async (request, reply) => { const { id } = request.params; - const user = selectUserById(db, parseInt(id)); + const user = await selectUserById(db, parseInt(id)); reply.send(user); }); @@ -163,7 +163,7 @@ fastify.get<{ Params: { login: string }; }>("/users/login/:login", async (request, reply) => { const { login } = request.params; - const user = selectUserByLogin(db, login); + const user = await selectUserByLogin(db, login); reply.send(user); }); -- 2.36.3 From e3ba698b3a39681f14fec20e47a814264768559f Mon Sep 17 00:00:00 2001 From: cofrizot Date: Fri, 17 May 2024 11:34:38 +0200 Subject: [PATCH 08/13] Add the languages table --- src/database.ts | 89 +++++++++++++++++++++++++++++++++++++++++++++++-- src/server.ts | 77 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 160 insertions(+), 6 deletions(-) diff --git a/src/database.ts b/src/database.ts index 3f7da04..b602b81 100644 --- a/src/database.ts +++ b/src/database.ts @@ -40,11 +40,11 @@ function getDB( params: any[] ): Promise { return new Promise((resolve, reject) => { - db.get(query, params, (err, row) => { + db.get(query, params, (err, row : any) => { if (err) { reject(err); } else { - resolve(); + resolve(row); } }); }); @@ -81,6 +81,12 @@ function closeDatabase(db: sqlite3.Database) { }); } +// Create all the tables in the database +function createTables(db: sqlite3.Database) { + createRegisteredUserTable(db); + createLanguageTable(db); +} + /////////////////////////// Gestion des utilisateurs /////////////////////////// // CREATE TABLE registered_user ( // id_user SERIAL PRIMARY KEY, @@ -172,12 +178,82 @@ function selectUserById(db: sqlite3.Database, id: number) { return getDB(db, selectUserByIdQuery, [id]); } +/////////////////////////// Gestion des Languages /////////////////////////// +// CREATE TABLE language ( +// id_language SERIAL PRIMARY KEY, +// designation VARCHAR(30) NOT NULL, +// version INT NOT NULL, +// ); + +// Créer la table language dans la base de données +function createLanguageTable(db: sqlite3.Database): Promise { + const tableLanguage = `CREATE TABLE IF NOT EXISTS language (id_language INTEGER PRIMARY KEY AUTOINCREMENT, designation TEXT NOT NULL, version INTEGER NOT NULL)`; + return runDB(db, tableLanguage, []); +} + +// Insérer un language dans la table language +function insertLanguage( + db: sqlite3.Database, + designation: string, + version: number +) { + const insertLanguageQuery = `INSERT INTO language (designation, version) VALUES (?, ?)`; + + return runDB(db, insertLanguageQuery, [designation, version]); +} + +// Modifier la designation d'un language dans la table language +function updateLanguageDesignation(db: sqlite3.Database, id: number, newDesignation: string) { + const updateLanguageDesignationQuery = `UPDATE language SET designation = ? WHERE id_language = ?`; + + return runDB(db, updateLanguageDesignationQuery, [newDesignation, id]); +} + +// Modifier la version d'un language dans la table language +function updateLanguageVersion( + db: sqlite3.Database, + id: number, + newVersion: number +) { + const updateLanguageVersionQuery = `UPDATE language SET version = ? WHERE id_language = ?`; + + return runDB(db, updateLanguageVersionQuery, [newVersion, id]); +} + +// Supprimer un language de la table language +function deleteLanguage(db: sqlite3.Database, id: number) { + const deleteLanguageQuery = `DELETE FROM language WHERE id_language = ?`; + + return runDB(db, deleteLanguageQuery, [id]); +} + +// Supprimer tous les languages de la table language +function deleteAllLanguages(db: sqlite3.Database) { + const deleteAllLanguagesQuery = `DELETE FROM language`; + + return runDB(db, deleteAllLanguagesQuery, []); +} + +// Sélectionner tous les languages de la table language +function selectAllLanguages(db: sqlite3.Database): Promise { + const selectAllLanguagesQuery = `SELECT * FROM language`; + + return allDB(db, selectAllLanguagesQuery); +} + +// Sélectionner un language par son ID +function selectLanguageById(db: sqlite3.Database, id: number) { + const selectLanguageByIdQuery = `SELECT * FROM language WHERE id_language = ?`; + + return getDB(db, selectLanguageByIdQuery, [id]); +} + /////////////////////////// Export des fonctions /////////////////////////// export { createDbDirectory, openDatabase, closeDatabase, - createRegisteredUserTable, + createTables, insertUser, updateUserLogin, updateUserPassword, @@ -187,4 +263,11 @@ export { selectAllUsers, selectUserByLogin, selectUserById, + insertLanguage, + updateLanguageDesignation, + updateLanguageVersion, + deleteLanguage, + deleteAllLanguages, + selectAllLanguages, + selectLanguageById, }; diff --git a/src/server.ts b/src/server.ts index a771e64..fa60b02 100644 --- a/src/server.ts +++ b/src/server.ts @@ -9,7 +9,7 @@ import { createDbDirectory, openDatabase, closeDatabase, - createRegisteredUserTable, + createTables, insertUser, updateUserLogin, updateUserPassword, @@ -19,6 +19,13 @@ import { selectAllUsers, selectUserByLogin, selectUserById, + insertLanguage, + updateLanguageDesignation, + updateLanguageVersion, + deleteLanguage, + deleteAllLanguages, + selectAllLanguages, + selectLanguageById, } from "./database"; const sender = new Push(); @@ -80,8 +87,8 @@ createDbDirectory(); // Ouvrir la base de données const db = openDatabase(); -// Créer la table registered_user si elle n'existe pas -createRegisteredUserTable(db); +// Créer les tables si elles n'existent pas +createTables(db); // Route pour créer un utilisateur fastify.post<{ @@ -167,6 +174,70 @@ fastify.get<{ reply.send(user); }); +// Route pour créer un language +fastify.post<{ + Body: { + designation: string; + version: string; + }; +}>("/languages", async (request, reply) => { + const { designation, version } = request.body; + insertLanguage(db, designation, parseInt(version)); + reply.send({ success: true }); +}); + +// Route pour mettre à jour la désignation d'un language +fastify.put<{ + Params: { id: string }; + Body: { newDesignation: string }; +}>("/languages/:id/designation", async (request, reply) => { + const { id } = request.params; + const { newDesignation } = request.body; + updateLanguageDesignation(db, parseInt(id), newDesignation); + reply.send({ success: true }); +}); + +// Route pour mettre à jour la version d'un language +fastify.put<{ + Params: { id: string }; + Body: { newVersion: number }; +}>("/languages/:id/version", async (request, reply) => { + const { id } = request.params; + const { newVersion } = request.body; + updateLanguageVersion(db, parseInt(id), newVersion); + reply.send({ success: true }); +}); + +// Route pour supprimer un language +fastify.delete<{ + Params: { id: string }; +}>("/languages/:id", async (request, reply) => { + const { id } = request.params; + deleteLanguage(db, parseInt(id)); + reply.send({ success: true }); +}); + +// Route pour supprimer tous les languages +fastify.delete("/languages", async (request, reply) => { + deleteAllLanguages(db); + reply.send({ success: true }); +}); + +// Route pour récupérer un language par son ID +fastify.get<{ + Params: { id: string }; +}>("/languages/:id", async (request, reply) => { + const { id } = request.params; + const language = await selectLanguageById(db, parseInt(id)); + reply.send(language); +}); + +// Route pour récupérer tous les languages +fastify.get("/languages", async (request, reply) => { + const languages = await selectAllLanguages(db); + reply.send(languages); +}); + // Forward output from the runner to the client async function forwardOutput() { -- 2.36.3 From 7c65066ca98d78453a6671806352e949b5e08263 Mon Sep 17 00:00:00 2001 From: cofrizot Date: Fri, 17 May 2024 11:47:36 +0200 Subject: [PATCH 09/13] Add the start of the work table --- src/database.ts | 60 +++++++++++++++++++++++++++++++++++++++++++++++++ src/server.ts | 48 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 108 insertions(+) diff --git a/src/database.ts b/src/database.ts index b602b81..f9f5531 100644 --- a/src/database.ts +++ b/src/database.ts @@ -85,6 +85,7 @@ function closeDatabase(db: sqlite3.Database) { function createTables(db: sqlite3.Database) { createRegisteredUserTable(db); createLanguageTable(db); + createWorkTable(db); } /////////////////////////// Gestion des utilisateurs /////////////////////////// @@ -248,6 +249,60 @@ function selectLanguageById(db: sqlite3.Database, id: number) { return getDB(db, selectLanguageByIdQuery, [id]); } +/////////////////////////// Gestion des works /////////////////////////// +// CREATE TABLE work ( +// id_work SERIAL PRIMARY KEY, +// user_id INT REFERENCES registered_user(id_user), +// language_id INT NOT NULL REFERENCES language(id_language) +// content TEXT NOT NULL, +// ); + +// Créer la table work dans la base de données +function createWorkTable(db: sqlite3.Database): Promise { + const tableWork = `CREATE TABLE IF NOT EXISTS work (id_work INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER REFERENCES registered_user(id_user), language_id INTEGER NOT NULL REFERENCES language(id_language), content TEXT NOT NULL)`; + return runDB(db, tableWork, []); +} + +// Insérer un work dans la table work +function insertWork( + db: sqlite3.Database, + user_id: number, + language_id: number, + content: string +) { + const insertWorkQuery = `INSERT INTO work (user_id, language_id, content) VALUES (?, ?, ?)`; + + return runDB(db, insertWorkQuery, [user_id, language_id, content]); +} + +// Sélectionner tous les works de la table work +function selectAllWorks(db: sqlite3.Database): Promise { + const selectAllWorksQuery = `SELECT * FROM work`; + + return allDB(db, selectAllWorksQuery); +} + +// Supprimer tous les works de la table work +function deleteAllWorks(db: sqlite3.Database) { + const deleteAllWorksQuery = `DELETE FROM work`; + + return runDB(db, deleteAllWorksQuery, []); +} + +// Supprimer un work de la table work +function deleteWork(db: sqlite3.Database, id: number) { + const deleteWorkQuery = `DELETE FROM work WHERE id_work = ?`; + + return runDB(db, deleteWorkQuery, [id]); +} + +// Sélectionner un work par son ID +function selectWorkById(db: sqlite3.Database, id: number) { + const selectWorkByIdQuery = `SELECT * FROM work WHERE id_work = ?`; + + return getDB(db, selectWorkByIdQuery, [id]); +} + /////////////////////////// Export des fonctions /////////////////////////// export { createDbDirectory, @@ -270,4 +325,9 @@ export { deleteAllLanguages, selectAllLanguages, selectLanguageById, + insertWork, + selectAllWorks, + deleteAllWorks, + deleteWork, + selectWorkById, }; diff --git a/src/server.ts b/src/server.ts index fa60b02..daff54c 100644 --- a/src/server.ts +++ b/src/server.ts @@ -26,6 +26,11 @@ import { deleteAllLanguages, selectAllLanguages, selectLanguageById, + insertWork, + selectAllWorks, + deleteAllWorks, + deleteWork, + selectWorkById, } from "./database"; const sender = new Push(); @@ -238,6 +243,49 @@ fastify.get("/languages", async (request, reply) => { reply.send(languages); }); +// Route pour créer un work +fastify.post<{ + Body: { + id_user: number; + id_language: number; + code: string; + }; +}>("/works", async (request, reply) => { + const { id_user, id_language, code } = request.body; + insertWork(db, id_user, id_language, code); + reply.send({ success: true }); +}); + +// Route pour récupérer tous les works +fastify.get("/works", async (request, reply) => { + const works = await selectAllWorks(db); + reply.send(works); +}); + +// Route pour supprimer tous les works +fastify.delete("/works", async (request, reply) => { + deleteAllWorks(db); + reply.send({ success: true }); +}); + +// Route pour supprimer un work +fastify.delete<{ + Params: { id: string }; +}>("/works/:id", async (request, reply) => { + const { id } = request.params; + deleteWork(db, parseInt(id)); + reply.send({ success: true }); +}); + +// Route pour récupérer un work par son ID +fastify.get<{ + Params: { id: string }; +}>("/works/:id", async (request, reply) => { + const { id } = request.params; + const work = await selectWorkById(db, parseInt(id)); + reply.send(work); +}); + // Forward output from the runner to the client async function forwardOutput() { -- 2.36.3 From 09842511b8836aff851447bb5f645b249666f782 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Wed, 22 May 2024 11:01:08 +0200 Subject: [PATCH 10/13] ajout du champ link a Work + methode supprimer user par login + revu des commentaires --- src/database.ts | 92 +++++++++++++++++++++++++++------------------ src/db/database.db | Bin 16384 -> 24576 bytes src/server.ts | 78 ++++++++++++++++++++++---------------- 3 files changed, 100 insertions(+), 70 deletions(-) diff --git a/src/database.ts b/src/database.ts index f9f5531..3c94f85 100644 --- a/src/database.ts +++ b/src/database.ts @@ -4,8 +4,9 @@ import fs from "fs"; const dbDirectory = "./src/db"; const dbFilePath = `${dbDirectory}/database.db`; -// Fonctions pour exécuter des requêtes SQL sur la base de données SQLite avec des promesses pour gérer les erreurs et les résultats asynchrones +/* Fonction pour exécuter une requête sur la base de données */ +/* Fonction pour exécuter une requête de modification de la base de données (INSERT, UPDATE, DELETE) */ function runDB( db: sqlite3.Database, query: string, @@ -22,6 +23,7 @@ function runDB( }); } +/* Fonction pour récupérer plusieurs lignes de la base de données */ function allDB(db: sqlite3.Database, query: string): Promise { return new Promise((resolve, reject) => { db.all(query, (err, rows) => { @@ -34,13 +36,14 @@ function allDB(db: sqlite3.Database, query: string): Promise { }); } +/* Fonction pour récupérer une seule ligne de la base de données */ function getDB( db: sqlite3.Database, query: string, params: any[] ): Promise { return new Promise((resolve, reject) => { - db.get(query, params, (err, row : any) => { + db.get(query, params, (err, row: any) => { if (err) { reject(err); } else { @@ -50,16 +53,16 @@ function getDB( }); } -// Fonctions pour la gestion de la base de données +/* Fonctions pour la gestion de la base de données */ -// Créer le répertoire db s'il n'existe pas +/* Créer le répertoire db s'il n'existe pas */ function createDbDirectory() { if (!fs.existsSync(dbDirectory)) { fs.mkdirSync(dbDirectory); } } -// Ouvrir la base de données +/* Ouvrir la base de données */ function openDatabase() { console.log("Ouverture de la connexion à la base de données."); return new sqlite3.Database( @@ -71,7 +74,7 @@ function openDatabase() { ); } -// Fermer la base de données +/* Fermer la base de données */ function closeDatabase(db: sqlite3.Database) { db.close((err) => { if (err) { @@ -81,7 +84,7 @@ function closeDatabase(db: sqlite3.Database) { }); } -// Create all the tables in the database +/* Create all the tables in the database */ function createTables(db: sqlite3.Database) { createRegisteredUserTable(db); createLanguageTable(db); @@ -97,14 +100,14 @@ function createTables(db: sqlite3.Database) { // UNIQUE (login) // ); -// Créer la table registered_user dans la base de données +/* Créer la table registered_user dans la base de données */ function createRegisteredUserTable(db: sqlite3.Database): Promise { const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; return runDB(db, tableRegisteredUser, []); } -// Insérer un utilisateur dans la table registered_user +/* Insérer un utilisateur dans la table registered_user */ function insertUser( db: sqlite3.Database, login: string, @@ -116,14 +119,14 @@ function insertUser( return runDB(db, insertUserQuery, [login, password, permissions]); } -// Modifier le login d'un utilisateur dans la table registered_user +/* Modifier le login d'un utilisateur dans la table registered_user */ function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) { const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; return runDB(db, updateUserLoginQuery, [newLogin, id]); } -// Modifier le mot de passe d'un utilisateur dans la table registered_user +/* Modifier le mot de passe d'un utilisateur dans la table registered_user */ function updateUserPassword( db: sqlite3.Database, id: number, @@ -134,6 +137,7 @@ function updateUserPassword( return runDB(db, updateUserPasswordQuery, [newPassword, id]); } +/* Modifier les permissions d'un utilisateur dans la table registered_user */ function updateUserPermissions( db: sqlite3.Database, id: number, @@ -144,35 +148,42 @@ function updateUserPermissions( return runDB(db, updateUserPermissionsQuery, [newPermissions, id]); } -// Supprimer un utilisateur de la table registered_user -function deleteUser(db: sqlite3.Database, id: number) { +/* Supprimer un utilisateur de la table registered_user par son ID */ +function deleteUserById(db: sqlite3.Database, id: number) { const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`; return runDB(db, deleteUserQuery, [id]); } -// Supprimer tous les utilisateurs de la table registered_user +/* Supprimer un utilisateur de la table registered_user par son login */ +function deleteUserByLogin(db: sqlite3.Database, login: string) { + const deleteUserQuery = `DELETE FROM registered_user WHERE login = ?`; + + return runDB(db, deleteUserQuery, [login]); +} + +/* Supprimer tous les utilisateurs de la table registered_user */ function deleteAllUsers(db: sqlite3.Database) { const deleteAllUsersQuery = `DELETE FROM registered_user`; return runDB(db, deleteAllUsersQuery, []); } -// Sélectionner tous les utilisateurs de la table registered_user +/* Sélectionner tous les utilisateurs de la table registered_user */ function selectAllUsers(db: sqlite3.Database): Promise { const selectAllUsersQuery = `SELECT * FROM registered_user`; return allDB(db, selectAllUsersQuery); } -// Sélectionner un utilisateur par son login +/* Sélectionner un utilisateur par son login */ function selectUserByLogin(db: sqlite3.Database, login: string) { const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`; return getDB(db, selectUserByLoginQuery, [login]); } -// Sélectionner un utilisateur par son ID +/* Sélectionner un utilisateur par son ID */ function selectUserById(db: sqlite3.Database, id: number) { const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`; @@ -186,13 +197,13 @@ function selectUserById(db: sqlite3.Database, id: number) { // version INT NOT NULL, // ); -// Créer la table language dans la base de données +/* Créer la table language dans la base de données */ function createLanguageTable(db: sqlite3.Database): Promise { const tableLanguage = `CREATE TABLE IF NOT EXISTS language (id_language INTEGER PRIMARY KEY AUTOINCREMENT, designation TEXT NOT NULL, version INTEGER NOT NULL)`; return runDB(db, tableLanguage, []); } -// Insérer un language dans la table language +/* Insérer un language dans la table language */ function insertLanguage( db: sqlite3.Database, designation: string, @@ -203,14 +214,18 @@ function insertLanguage( return runDB(db, insertLanguageQuery, [designation, version]); } -// Modifier la designation d'un language dans la table language -function updateLanguageDesignation(db: sqlite3.Database, id: number, newDesignation: string) { +/* Modifier la designation d'un language dans la table language */ +function updateLanguageDesignation( + db: sqlite3.Database, + id: number, + newDesignation: string +) { const updateLanguageDesignationQuery = `UPDATE language SET designation = ? WHERE id_language = ?`; return runDB(db, updateLanguageDesignationQuery, [newDesignation, id]); } -// Modifier la version d'un language dans la table language +/* Modifier la version d'un language dans la table language */ function updateLanguageVersion( db: sqlite3.Database, id: number, @@ -221,28 +236,28 @@ function updateLanguageVersion( return runDB(db, updateLanguageVersionQuery, [newVersion, id]); } -// Supprimer un language de la table language +/* Supprimer un language de la table language par son ID */ function deleteLanguage(db: sqlite3.Database, id: number) { const deleteLanguageQuery = `DELETE FROM language WHERE id_language = ?`; return runDB(db, deleteLanguageQuery, [id]); } -// Supprimer tous les languages de la table language +/* Supprimer tous les languages de la table language */ function deleteAllLanguages(db: sqlite3.Database) { const deleteAllLanguagesQuery = `DELETE FROM language`; return runDB(db, deleteAllLanguagesQuery, []); } -// Sélectionner tous les languages de la table language +/* Sélectionner tous les languages de la table language */ function selectAllLanguages(db: sqlite3.Database): Promise { const selectAllLanguagesQuery = `SELECT * FROM language`; return allDB(db, selectAllLanguagesQuery); } -// Sélectionner un language par son ID +/* Sélectionner un language par son ID */ function selectLanguageById(db: sqlite3.Database, id: number) { const selectLanguageByIdQuery = `SELECT * FROM language WHERE id_language = ?`; @@ -252,51 +267,53 @@ function selectLanguageById(db: sqlite3.Database, id: number) { /////////////////////////// Gestion des works /////////////////////////// // CREATE TABLE work ( // id_work SERIAL PRIMARY KEY, +// link CHAR(36) NOT NULL, // user_id INT REFERENCES registered_user(id_user), // language_id INT NOT NULL REFERENCES language(id_language) -// content TEXT NOT NULL, +// content TEXT NOT NULL, // ); -// Créer la table work dans la base de données +/* Créer la table work dans la base de données */ function createWorkTable(db: sqlite3.Database): Promise { - const tableWork = `CREATE TABLE IF NOT EXISTS work (id_work INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER REFERENCES registered_user(id_user), language_id INTEGER NOT NULL REFERENCES language(id_language), content TEXT NOT NULL)`; + const tableWork = `CREATE TABLE IF NOT EXISTS work (id_work INTEGER PRIMARY KEY AUTOINCREMENT, link CHAR(36) NOT NULL, user_id INTEGER REFERENCES registered_user(id_user), language_id INTEGER NOT NULL REFERENCES language(id_language), content TEXT NOT NULL)`; return runDB(db, tableWork, []); } -// Insérer un work dans la table work +/* Insérer un work dans la table work */ function insertWork( db: sqlite3.Database, + link: string, user_id: number, language_id: number, content: string ) { - const insertWorkQuery = `INSERT INTO work (user_id, language_id, content) VALUES (?, ?, ?)`; + const insertWorkQuery = `INSERT INTO work (link, user_id, language_id, content) VALUES (?, ?, ?, ?)`; - return runDB(db, insertWorkQuery, [user_id, language_id, content]); + return runDB(db, insertWorkQuery, [link, user_id, language_id, content]); } -// Sélectionner tous les works de la table work +/* Sélectionner tous les works de la table work */ function selectAllWorks(db: sqlite3.Database): Promise { const selectAllWorksQuery = `SELECT * FROM work`; return allDB(db, selectAllWorksQuery); } -// Supprimer tous les works de la table work +/* Supprimer tous les works de la table work */ function deleteAllWorks(db: sqlite3.Database) { const deleteAllWorksQuery = `DELETE FROM work`; return runDB(db, deleteAllWorksQuery, []); } -// Supprimer un work de la table work +/* Supprimer un work de la table work */ function deleteWork(db: sqlite3.Database, id: number) { const deleteWorkQuery = `DELETE FROM work WHERE id_work = ?`; return runDB(db, deleteWorkQuery, [id]); } -// Sélectionner un work par son ID +/* Sélectionner un work par son ID */ function selectWorkById(db: sqlite3.Database, id: number) { const selectWorkByIdQuery = `SELECT * FROM work WHERE id_work = ?`; @@ -313,7 +330,8 @@ export { updateUserLogin, updateUserPassword, updateUserPermissions, - deleteUser, + deleteUserById, + deleteUserByLogin, deleteAllUsers, selectAllUsers, selectUserByLogin, diff --git a/src/db/database.db b/src/db/database.db index 05f44b14f689c6a10f68b5793f726f70695313a4..78185c29a42a5ab65773058bd25a2566fb9eaa7c 100644 GIT binary patch delta 575 zcmZo@U~D+RI6+#Fje&sygkgYrqK>gR8-rfaB3}L<46M8|416#6ck)f+{lhD>v2huX zQDZDCySS(*W3y~YVp2|Od45qg2(vi{xjKfpDug&X`M4^8L=-eKQ{q94$=3WT^`*tB zMe&&_3Z8x;uI{cu3PG-Ju0gJT&aS}##h--u|P!m+6W}`R@ySS_@V-q9T2QUpV znia(-Fj25?U>uN-Oj1&dGt=`DOEUBGKsF#O&`~H$Eh+{H!#oSOdh;~CJVrJ~{tpcN zA2tgLJmZ(*V`OCz7v(HTEiN%MG%_~f0!9QQ|91xd??Cyt{GuGp;t)w*pac{DV+Q^= z{EvZB*ZJkxnV3a6K>;kp$gItY7K*%^85P(CnD{pW)h_4v_hn>bVB~C+WL3`0OU@}x zNmZ~ZE=kGE*UPX|$OHyaZenJhMp=Glie|M!K@m_SO+(!yH76%uAw0h*Cqg>UmT ZzC6awEDnG88M!tyI("/users/:id", async (request, reply) => { const { id } = request.params; - await deleteUser(db, parseInt(id)); + await deleteUserById(db, parseInt(id)); reply.send({ success: true }); }); -// Route pour supprimer tous les utilisateurs +/* Route pour supprimer un utilisateur par son login */ +fastify.delete<{ + Params: { login: string }; +}>("/users/login/:login", async (request, reply) => { + const { login } = request.params; + await deleteUserByLogin(db, login); + reply.send({ success: true }); +}); + +/* Route pour supprimer tous les utilisateurs */ fastify.delete("/users", async (request, reply) => { await deleteAllUsers(db); reply.send({ success: true }); }); -// Route pour récupérer tous les utilisateurs + +/* Route pour récupérer tous les utilisateurs */ fastify.get("/users", async (request, reply) => { const users = await selectAllUsers(db); reply.send(users); }); -// Route pour récupérer un utilisateur par son ID +/* Route pour récupérer un utilisateur par son ID */ fastify.get<{ Params: { id: string }; }>("/users/:id", async (request, reply) => { @@ -170,7 +181,7 @@ fastify.get<{ reply.send(user); }); -// Route pour récupérer un utilisateur par son login +/* Route pour récupérer un utilisateur par son login */ fastify.get<{ Params: { login: string }; }>("/users/login/:login", async (request, reply) => { @@ -179,7 +190,7 @@ fastify.get<{ reply.send(user); }); -// Route pour créer un language +/* Route pour créer un language */ fastify.post<{ Body: { designation: string; @@ -191,7 +202,7 @@ fastify.post<{ reply.send({ success: true }); }); -// Route pour mettre à jour la désignation d'un language +/* Route pour mettre à jour la désignation d'un language */ fastify.put<{ Params: { id: string }; Body: { newDesignation: string }; @@ -202,7 +213,7 @@ fastify.put<{ reply.send({ success: true }); }); -// Route pour mettre à jour la version d'un language +/* Route pour mettre à jour la version d'un language */ fastify.put<{ Params: { id: string }; Body: { newVersion: number }; @@ -213,7 +224,7 @@ fastify.put<{ reply.send({ success: true }); }); -// Route pour supprimer un language +/* Route pour supprimer un language */ fastify.delete<{ Params: { id: string }; }>("/languages/:id", async (request, reply) => { @@ -222,13 +233,13 @@ fastify.delete<{ reply.send({ success: true }); }); -// Route pour supprimer tous les languages +/* Route pour supprimer tous les languages */ fastify.delete("/languages", async (request, reply) => { deleteAllLanguages(db); reply.send({ success: true }); }); -// Route pour récupérer un language par son ID +/* Route pour récupérer un language par son ID */ fastify.get<{ Params: { id: string }; }>("/languages/:id", async (request, reply) => { @@ -237,38 +248,39 @@ fastify.get<{ reply.send(language); }); -// Route pour récupérer tous les languages +/* Route pour récupérer tous les languages */ fastify.get("/languages", async (request, reply) => { const languages = await selectAllLanguages(db); reply.send(languages); }); -// Route pour créer un work +/* Route pour créer un work */ fastify.post<{ Body: { id_user: number; + link: string; id_language: number; code: string; }; }>("/works", async (request, reply) => { - const { id_user, id_language, code } = request.body; - insertWork(db, id_user, id_language, code); + const { id_user, link, id_language, code } = request.body; + insertWork(db, link, id_user, id_language, code); reply.send({ success: true }); }); -// Route pour récupérer tous les works +/* Route pour récupérer tous les works */ fastify.get("/works", async (request, reply) => { const works = await selectAllWorks(db); reply.send(works); }); -// Route pour supprimer tous les works +/* Route pour supprimer tous les works */ fastify.delete("/works", async (request, reply) => { deleteAllWorks(db); reply.send({ success: true }); }); -// Route pour supprimer un work +/* Route pour supprimer un work par son ID */ fastify.delete<{ Params: { id: string }; }>("/works/:id", async (request, reply) => { @@ -277,7 +289,7 @@ fastify.delete<{ reply.send({ success: true }); }); -// Route pour récupérer un work par son ID +/* Route pour récupérer un work par son ID */ fastify.get<{ Params: { id: string }; }>("/works/:id", async (request, reply) => { @@ -286,8 +298,7 @@ fastify.get<{ reply.send(work); }); -// Forward output from the runner to the client - +/* Forward output est une fonction asynchrone qui permet de récupérer les messages envoyés par le container et de les renvoyer au client */ async function forwardOutput() { for await (const [buff] of receiver) { const messageType = buff.readInt8(); @@ -323,4 +334,5 @@ async function forwardOutput() { } } +/* Lancer le serveur et la fonction forwardOutput sur le même thread en parallèle */ await Promise.all([fastify.listen({ port: 3000 }), forwardOutput()]); -- 2.36.3 From 91cfb9e8e6a06a8d48b5fca73fa987b09dd61bcb Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Wed, 22 May 2024 15:22:57 +0200 Subject: [PATCH 11/13] correctifs par rapport a reponse de la demande d ajout --- .gitignore | 1 + package.json | 1 - src/database.ts | 103 ++++------ src/db/database.db | Bin 24576 -> 24576 bytes src/server.ts | 469 ++++++++++++++++++++++++++++----------------- 5 files changed, 339 insertions(+), 235 deletions(-) diff --git a/.gitignore b/.gitignore index 8195efd..da0b00d 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ package-lock.json *.js *.tsbuildinfo *.d.ts +*.db diff --git a/package.json b/package.json index 23bfe2a..85171a3 100644 --- a/package.json +++ b/package.json @@ -16,7 +16,6 @@ "@fastify/type-provider-typebox": "^4.0.0", "@sinclair/typebox": "^0.32.9", "fastify": "^4.27.0", - "fastify-sqlite-typed": "^0.1.1", "nanoid": "^5.0.4", "sqlite3": "^5.1.7", "zeromq": "6.0.0-beta.19" diff --git a/src/database.ts b/src/database.ts index 3c94f85..caa5b2f 100644 --- a/src/database.ts +++ b/src/database.ts @@ -7,7 +7,7 @@ const dbFilePath = `${dbDirectory}/database.db`; /* Fonction pour exécuter une requête sur la base de données */ /* Fonction pour exécuter une requête de modification de la base de données (INSERT, UPDATE, DELETE) */ -function runDB( +export function runDB( db: sqlite3.Database, query: string, params: any[] @@ -24,7 +24,10 @@ function runDB( } /* Fonction pour récupérer plusieurs lignes de la base de données */ -function allDB(db: sqlite3.Database, query: string): Promise { +export function allDB( + db: sqlite3.Database, + query: string +): Promise { return new Promise((resolve, reject) => { db.all(query, (err, rows) => { if (err) { @@ -37,11 +40,11 @@ function allDB(db: sqlite3.Database, query: string): Promise { } /* Fonction pour récupérer une seule ligne de la base de données */ -function getDB( +export function getDB( db: sqlite3.Database, query: string, params: any[] -): Promise { +): Promise { return new Promise((resolve, reject) => { db.get(query, params, (err, row: any) => { if (err) { @@ -56,14 +59,14 @@ function getDB( /* Fonctions pour la gestion de la base de données */ /* Créer le répertoire db s'il n'existe pas */ -function createDbDirectory() { +export function createDbDirectory() { if (!fs.existsSync(dbDirectory)) { fs.mkdirSync(dbDirectory); } } /* Ouvrir la base de données */ -function openDatabase() { +export function openDatabase() { console.log("Ouverture de la connexion à la base de données."); return new sqlite3.Database( dbFilePath, @@ -75,7 +78,7 @@ function openDatabase() { } /* Fermer la base de données */ -function closeDatabase(db: sqlite3.Database) { +export function closeDatabase(db: sqlite3.Database) { db.close((err) => { if (err) { console.error(err.message); @@ -85,7 +88,7 @@ function closeDatabase(db: sqlite3.Database) { } /* Create all the tables in the database */ -function createTables(db: sqlite3.Database) { +export function createTables(db: sqlite3.Database) { createRegisteredUserTable(db); createLanguageTable(db); createWorkTable(db); @@ -101,14 +104,14 @@ function createTables(db: sqlite3.Database) { // ); /* Créer la table registered_user dans la base de données */ -function createRegisteredUserTable(db: sqlite3.Database): Promise { +export function createRegisteredUserTable(db: sqlite3.Database): Promise { const tableRegisteredUser = `CREATE TABLE IF NOT EXISTS registered_user (id_user INTEGER PRIMARY KEY AUTOINCREMENT, login TEXT NOT NULL, password TEXT NOT NULL, permissions INTEGER NOT NULL, UNIQUE (login))`; return runDB(db, tableRegisteredUser, []); } /* Insérer un utilisateur dans la table registered_user */ -function insertUser( +export function insertUser( db: sqlite3.Database, login: string, password: string, @@ -120,14 +123,18 @@ function insertUser( } /* Modifier le login d'un utilisateur dans la table registered_user */ -function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) { +export function updateUserLogin( + db: sqlite3.Database, + id: number, + newLogin: string +) { const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; return runDB(db, updateUserLoginQuery, [newLogin, id]); } /* Modifier le mot de passe d'un utilisateur dans la table registered_user */ -function updateUserPassword( +export function updateUserPassword( db: sqlite3.Database, id: number, newPassword: string @@ -138,7 +145,7 @@ function updateUserPassword( } /* Modifier les permissions d'un utilisateur dans la table registered_user */ -function updateUserPermissions( +export function updateUserPermissions( db: sqlite3.Database, id: number, newPermissions: number @@ -149,42 +156,42 @@ function updateUserPermissions( } /* Supprimer un utilisateur de la table registered_user par son ID */ -function deleteUserById(db: sqlite3.Database, id: number) { +export function deleteUserById(db: sqlite3.Database, id: number) { const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`; return runDB(db, deleteUserQuery, [id]); } /* Supprimer un utilisateur de la table registered_user par son login */ -function deleteUserByLogin(db: sqlite3.Database, login: string) { +export function deleteUserByLogin(db: sqlite3.Database, login: string) { const deleteUserQuery = `DELETE FROM registered_user WHERE login = ?`; return runDB(db, deleteUserQuery, [login]); } /* Supprimer tous les utilisateurs de la table registered_user */ -function deleteAllUsers(db: sqlite3.Database) { +export function deleteAllUsers(db: sqlite3.Database) { const deleteAllUsersQuery = `DELETE FROM registered_user`; return runDB(db, deleteAllUsersQuery, []); } /* Sélectionner tous les utilisateurs de la table registered_user */ -function selectAllUsers(db: sqlite3.Database): Promise { +export function selectAllUsers(db: sqlite3.Database): Promise { const selectAllUsersQuery = `SELECT * FROM registered_user`; return allDB(db, selectAllUsersQuery); } /* Sélectionner un utilisateur par son login */ -function selectUserByLogin(db: sqlite3.Database, login: string) { +export function selectUserByLogin(db: sqlite3.Database, login: string) { const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`; return getDB(db, selectUserByLoginQuery, [login]); } /* Sélectionner un utilisateur par son ID */ -function selectUserById(db: sqlite3.Database, id: number) { +export function selectUserById(db: sqlite3.Database, id: number) { const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`; return getDB(db, selectUserByIdQuery, [id]); @@ -198,13 +205,13 @@ function selectUserById(db: sqlite3.Database, id: number) { // ); /* Créer la table language dans la base de données */ -function createLanguageTable(db: sqlite3.Database): Promise { +export function createLanguageTable(db: sqlite3.Database): Promise { const tableLanguage = `CREATE TABLE IF NOT EXISTS language (id_language INTEGER PRIMARY KEY AUTOINCREMENT, designation TEXT NOT NULL, version INTEGER NOT NULL)`; return runDB(db, tableLanguage, []); } /* Insérer un language dans la table language */ -function insertLanguage( +export function insertLanguage( db: sqlite3.Database, designation: string, version: number @@ -215,7 +222,7 @@ function insertLanguage( } /* Modifier la designation d'un language dans la table language */ -function updateLanguageDesignation( +export function updateLanguageDesignation( db: sqlite3.Database, id: number, newDesignation: string @@ -226,7 +233,7 @@ function updateLanguageDesignation( } /* Modifier la version d'un language dans la table language */ -function updateLanguageVersion( +export function updateLanguageVersion( db: sqlite3.Database, id: number, newVersion: number @@ -237,28 +244,28 @@ function updateLanguageVersion( } /* Supprimer un language de la table language par son ID */ -function deleteLanguage(db: sqlite3.Database, id: number) { +export function deleteLanguage(db: sqlite3.Database, id: number) { const deleteLanguageQuery = `DELETE FROM language WHERE id_language = ?`; return runDB(db, deleteLanguageQuery, [id]); } /* Supprimer tous les languages de la table language */ -function deleteAllLanguages(db: sqlite3.Database) { +export function deleteAllLanguages(db: sqlite3.Database) { const deleteAllLanguagesQuery = `DELETE FROM language`; return runDB(db, deleteAllLanguagesQuery, []); } /* Sélectionner tous les languages de la table language */ -function selectAllLanguages(db: sqlite3.Database): Promise { +export function selectAllLanguages(db: sqlite3.Database): Promise { const selectAllLanguagesQuery = `SELECT * FROM language`; return allDB(db, selectAllLanguagesQuery); } /* Sélectionner un language par son ID */ -function selectLanguageById(db: sqlite3.Database, id: number) { +export function selectLanguageById(db: sqlite3.Database, id: number) { const selectLanguageByIdQuery = `SELECT * FROM language WHERE id_language = ?`; return getDB(db, selectLanguageByIdQuery, [id]); @@ -274,13 +281,13 @@ function selectLanguageById(db: sqlite3.Database, id: number) { // ); /* Créer la table work dans la base de données */ -function createWorkTable(db: sqlite3.Database): Promise { +export function createWorkTable(db: sqlite3.Database): Promise { const tableWork = `CREATE TABLE IF NOT EXISTS work (id_work INTEGER PRIMARY KEY AUTOINCREMENT, link CHAR(36) NOT NULL, user_id INTEGER REFERENCES registered_user(id_user), language_id INTEGER NOT NULL REFERENCES language(id_language), content TEXT NOT NULL)`; return runDB(db, tableWork, []); } /* Insérer un work dans la table work */ -function insertWork( +export function insertWork( db: sqlite3.Database, link: string, user_id: number, @@ -293,59 +300,29 @@ function insertWork( } /* Sélectionner tous les works de la table work */ -function selectAllWorks(db: sqlite3.Database): Promise { +export function selectAllWorks(db: sqlite3.Database): Promise { const selectAllWorksQuery = `SELECT * FROM work`; return allDB(db, selectAllWorksQuery); } /* Supprimer tous les works de la table work */ -function deleteAllWorks(db: sqlite3.Database) { +export function deleteAllWorks(db: sqlite3.Database) { const deleteAllWorksQuery = `DELETE FROM work`; return runDB(db, deleteAllWorksQuery, []); } /* Supprimer un work de la table work */ -function deleteWork(db: sqlite3.Database, id: number) { +export function deleteWork(db: sqlite3.Database, id: number) { const deleteWorkQuery = `DELETE FROM work WHERE id_work = ?`; return runDB(db, deleteWorkQuery, [id]); } /* Sélectionner un work par son ID */ -function selectWorkById(db: sqlite3.Database, id: number) { +export function selectWorkById(db: sqlite3.Database, id: number) { const selectWorkByIdQuery = `SELECT * FROM work WHERE id_work = ?`; return getDB(db, selectWorkByIdQuery, [id]); } - -/////////////////////////// Export des fonctions /////////////////////////// -export { - createDbDirectory, - openDatabase, - closeDatabase, - createTables, - insertUser, - updateUserLogin, - updateUserPassword, - updateUserPermissions, - deleteUserById, - deleteUserByLogin, - deleteAllUsers, - selectAllUsers, - selectUserByLogin, - selectUserById, - insertLanguage, - updateLanguageDesignation, - updateLanguageVersion, - deleteLanguage, - deleteAllLanguages, - selectAllLanguages, - selectLanguageById, - insertWork, - selectAllWorks, - deleteAllWorks, - deleteWork, - selectWorkById, -}; diff --git a/src/db/database.db b/src/db/database.db index 78185c29a42a5ab65773058bd25a2566fb9eaa7c..c33d49ac73d18762af7066538a6cd165d31ee32b 100644 GIT binary patch delta 175 zcmZoTz}Rqrae_1>$3z)tMvjdMOZd5%`7bc=f8c+>e_^wrz#)DGK4w-1aZ%2a)Z!9j zLnC7oJ|;Nd2*jWKL0$x?=`jQUcmB8hkAa%5@@sN3i!*|CFvD0zOdQPOU{efv`QI=w z@t+e8^>Mz)O!OZeFs`9Co5f7mSO@Qi=*2YC@7|2qT!cOd^QzbFT@ vIA=*}afu->0|NsS|6>OJH~f!*QrG!;*_oI{Im`2lvV|C#wKspT7f=8IG!YvO diff --git a/src/server.ts b/src/server.ts index 5d39fb0..088851e 100644 --- a/src/server.ts +++ b/src/server.ts @@ -5,34 +5,7 @@ import { nanoid } from "nanoid"; import { allocateBuffer, IMAGES } from "runner"; import { Pull, Push } from "zeromq"; -import { - createDbDirectory, - openDatabase, - closeDatabase, - createTables, - insertUser, - updateUserLogin, - updateUserPassword, - updateUserPermissions, - deleteUserById, - deleteUserByLogin, - deleteAllUsers, - selectAllUsers, - selectUserByLogin, - selectUserById, - insertLanguage, - updateLanguageDesignation, - updateLanguageVersion, - deleteLanguage, - deleteAllLanguages, - selectAllLanguages, - selectLanguageById, - insertWork, - selectAllWorks, - deleteAllWorks, - deleteWork, - selectWorkById, -} from "./database"; +import * as db from "./database"; const sender = new Push(); await sender.bind(`tcp://127.0.0.1:5557`); @@ -88,215 +61,369 @@ fastify.post( /* Database */ /* Création du répertoire de la base de données s'il n'existe pas */ -createDbDirectory(); +db.createDbDirectory(); /* Ouvrir la base de données */ -const db = openDatabase(); +const database = db.openDatabase(); /* Créer les tables si elles n'existent pas */ -createTables(db); +db.createTables(database); /* Route pour créer un utilisateur */ -fastify.post<{ - Body: { - login: string; - password: string; - permissions: number; - }; -}>("/users", async (request, reply) => { - const { login, password, permissions } = request.body; - insertUser(db, login, password, permissions); - reply.send({ success: true }); -}); +fastify.post( + "/users", + { + schema: { + body: Type.Object({ + login: Type.String(), + password: Type.String(), + permissions: Type.Number(), + }), + }, + }, + async (request, reply) => { + const { login, password, permissions } = request.body; + db.insertUser(database, login, password, permissions); + reply.send({ success: true }); + } +); /* Route pour mettre à jour le login d'un utilisateur */ -fastify.put<{ - Params: { id: string }; - Body: { newLogin: string }; -}>("/users/:id/login", async (request, reply) => { - const { id } = request.params; - const { newLogin } = request.body; - updateUserLogin(db, parseInt(id), newLogin); - reply.send({ success: true }); -}); +fastify.put( + "/users/:id/login", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + body: Type.Object({ + newLogin: Type.String(), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const { newLogin } = request.body; + db.updateUserLogin(database, id, newLogin); + reply.send({ success: true }); + } +); /* Route pour mettre à jour le mot de passe d'un utilisateur */ -fastify.put<{ - Params: { id: string }; - Body: { newPassword: string }; -}>("/users/:id/password", async (request, reply) => { - const { id } = request.params; - const { newPassword } = request.body; - await updateUserPassword(db, parseInt(id), newPassword); - reply.send({ success: true }); -}); +fastify.put( + "/users/:id/password", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + body: Type.Object({ + newPassword: Type.String(), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const { newPassword } = request.body; + db.updateUserPassword(database, id, newPassword); + reply.send({ success: true }); + } +); /* Route pour mettre à jour les permissions d'un utilisateur */ -fastify.put<{ - Params: { id: string }; - Body: { newPermissions: number }; -}>("/users/:id/permissions", async (request, reply) => { - const { id } = request.params; - const { newPermissions } = request.body; - await updateUserPermissions(db, parseInt(id), newPermissions); - reply.send({ success: true }); -}); +fastify.put( + "/users/:id/permissions", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + body: Type.Object({ + newPermissions: Type.Number(), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const { newPermissions } = request.body; + await db.updateUserPermissions(database, id, newPermissions); + reply.send({ success: true }); + } +); /* Route pour supprimer un utilisateur par son ID */ -fastify.delete<{ - Params: { id: string }; -}>("/users/:id", async (request, reply) => { - const { id } = request.params; - await deleteUserById(db, parseInt(id)); - reply.send({ success: true }); -}); +fastify.delete( + "/users/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + await db.deleteUserById(database, id); + reply.send({ success: true }); + } +); /* Route pour supprimer un utilisateur par son login */ -fastify.delete<{ - Params: { login: string }; -}>("/users/login/:login", async (request, reply) => { - const { login } = request.params; - await deleteUserByLogin(db, login); - reply.send({ success: true }); -}); +fastify.delete( + "/users/login/:login", + { + schema: { + params: Type.Object({ + login: Type.String(), + }), + }, + }, + async (request, reply) => { + const { login } = request.params; + await db.deleteUserByLogin(database, login); + reply.send({ success: true }); + } +); /* Route pour supprimer tous les utilisateurs */ fastify.delete("/users", async (request, reply) => { - await deleteAllUsers(db); + await db.deleteAllUsers(database); reply.send({ success: true }); }); /* Route pour récupérer tous les utilisateurs */ fastify.get("/users", async (request, reply) => { - const users = await selectAllUsers(db); + const users = await db.selectAllUsers(database); reply.send(users); }); /* Route pour récupérer un utilisateur par son ID */ -fastify.get<{ - Params: { id: string }; -}>("/users/:id", async (request, reply) => { - const { id } = request.params; - const user = await selectUserById(db, parseInt(id)); - reply.send(user); -}); +fastify.get( + "/users/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const user = await db.selectUserById(database, id); + reply.send(user); + } +); /* Route pour récupérer un utilisateur par son login */ -fastify.get<{ - Params: { login: string }; -}>("/users/login/:login", async (request, reply) => { - const { login } = request.params; - const user = await selectUserByLogin(db, login); - reply.send(user); -}); +fastify.get( + "/users/login/:login", + { + schema: { + params: Type.Object({ + login: Type.String(), + }), + }, + }, + async (request, reply) => { + const { login } = request.params; + const user = await db.selectUserByLogin(database, login); + reply.send(user); + } +); /* Route pour créer un language */ -fastify.post<{ - Body: { - designation: string; - version: string; - }; -}>("/languages", async (request, reply) => { - const { designation, version } = request.body; - insertLanguage(db, designation, parseInt(version)); - reply.send({ success: true }); -}); +fastify.post( + "/languages", + { + schema: { + body: Type.Object({ + designation: Type.String(), + version: Type.Number(), + }), + }, + }, + async (request, reply) => { + const { designation, version } = request.body; + db.insertLanguage(database, designation, version); + reply.send({ success: true }); + } +); /* Route pour mettre à jour la désignation d'un language */ -fastify.put<{ - Params: { id: string }; - Body: { newDesignation: string }; -}>("/languages/:id/designation", async (request, reply) => { - const { id } = request.params; - const { newDesignation } = request.body; - updateLanguageDesignation(db, parseInt(id), newDesignation); - reply.send({ success: true }); -}); +fastify.put( + "/languages/:id/designation", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + body: Type.Object({ + newDesignation: Type.String(), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const { newDesignation } = request.body; + db.updateLanguageDesignation(database, id, newDesignation); + reply.send({ success: true }); + } +); /* Route pour mettre à jour la version d'un language */ -fastify.put<{ - Params: { id: string }; - Body: { newVersion: number }; -}>("/languages/:id/version", async (request, reply) => { - const { id } = request.params; - const { newVersion } = request.body; - updateLanguageVersion(db, parseInt(id), newVersion); - reply.send({ success: true }); -}); +fastify.put( + "/languages/:id/version", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + body: Type.Object({ + newVersion: Type.Number(), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const { newVersion } = request.body; + db.updateLanguageVersion(database, id, newVersion); + reply.send({ success: true }); + } +); /* Route pour supprimer un language */ -fastify.delete<{ - Params: { id: string }; -}>("/languages/:id", async (request, reply) => { - const { id } = request.params; - deleteLanguage(db, parseInt(id)); - reply.send({ success: true }); -}); +fastify.delete( + "/languages/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + db.deleteLanguage(database, id); + reply.send({ success: true }); + } +); /* Route pour supprimer tous les languages */ fastify.delete("/languages", async (request, reply) => { - deleteAllLanguages(db); + db.deleteAllLanguages(database); reply.send({ success: true }); }); /* Route pour récupérer un language par son ID */ -fastify.get<{ - Params: { id: string }; -}>("/languages/:id", async (request, reply) => { - const { id } = request.params; - const language = await selectLanguageById(db, parseInt(id)); - reply.send(language); -}); +fastify.get( + "/languages/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const language = await db.selectLanguageById(database, id); + reply.send(language); + } +); /* Route pour récupérer tous les languages */ fastify.get("/languages", async (request, reply) => { - const languages = await selectAllLanguages(db); + const languages = await db.selectAllLanguages(database); reply.send(languages); }); /* Route pour créer un work */ -fastify.post<{ - Body: { - id_user: number; - link: string; - id_language: number; - code: string; - }; -}>("/works", async (request, reply) => { - const { id_user, link, id_language, code } = request.body; - insertWork(db, link, id_user, id_language, code); - reply.send({ success: true }); -}); +fastify.post( + "/works", + { + schema: { + body: Type.Object({ + id_user: Type.Number(), + link: Type.String(), + id_language: Type.Number(), + code: Type.String(), + }), + }, + }, + async (request, reply) => { + const { id_user, link, id_language, code } = request.body; + db.insertWork(database, link, id_user, id_language, code); + reply.send({ success: true }); + } +); /* Route pour récupérer tous les works */ fastify.get("/works", async (request, reply) => { - const works = await selectAllWorks(db); + const works = await db.selectAllWorks(database); reply.send(works); }); /* Route pour supprimer tous les works */ fastify.delete("/works", async (request, reply) => { - deleteAllWorks(db); + db.deleteAllWorks(database); reply.send({ success: true }); }); /* Route pour supprimer un work par son ID */ -fastify.delete<{ - Params: { id: string }; -}>("/works/:id", async (request, reply) => { - const { id } = request.params; - deleteWork(db, parseInt(id)); - reply.send({ success: true }); -}); +fastify.delete( + "/works/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + db.deleteWork(database, id); + reply.send({ success: true }); + } +); /* Route pour récupérer un work par son ID */ -fastify.get<{ - Params: { id: string }; -}>("/works/:id", async (request, reply) => { - const { id } = request.params; - const work = await selectWorkById(db, parseInt(id)); - reply.send(work); -}); +fastify.get( + "/works/:id", + { + schema: { + params: Type.Object({ + id: Type.Number({ + minimum: 0, + }), + }), + }, + }, + async (request, reply) => { + const { id } = request.params; + const work = await db.selectWorkById(database, id); + reply.send(work); + } +); /* Forward output est une fonction asynchrone qui permet de récupérer les messages envoyés par le container et de les renvoyer au client */ async function forwardOutput() { -- 2.36.3 From 49cf852117fd8f5e7dea26e950b549367eb7e350 Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Wed, 22 May 2024 15:58:18 +0200 Subject: [PATCH 12/13] fail build drone --- src/runner.ts | 26 ++++++++++++++++++-------- src/server.ts | 2 ++ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/src/runner.ts b/src/runner.ts index 2dc383b..290e8bb 100644 --- a/src/runner.ts +++ b/src/runner.ts @@ -1,8 +1,12 @@ -export const RUNNERS = ['bash', 'moshell', 'bun', 'typescript'] as const; +export const RUNNERS = ["bash", "moshell", "bun", "typescript"] as const; const ALLOWED_LANGUAGES = new Set(RUNNERS); -const aliases: Record = { - 'JavaScript': 'bun', - 'TypeScript': 'typescript', +const aliases: Record = { + JavaScript: "bun", + TypeScript: "typescript", +}; +export const IMAGES = { + logo: "logo.png", + background: "background.png", }; /** @@ -12,9 +16,15 @@ const aliases: Record = { * @param code The code to be executed. * @param image The image to be used. */ -export function allocateBuffer(jobId: string, code: string, image: string): Buffer { +export function allocateBuffer( + jobId: string, + code: string, + image: string +): Buffer { let cur = 0; - const buffer = Buffer.allocUnsafe(jobId.length + image.length + code.length + 9); + const buffer = Buffer.allocUnsafe( + jobId.length + image.length + code.length + 9 + ); cur = buffer.writeUInt8(0, cur); cur += buffer.write(jobId, cur); cur = buffer.writeUInt32BE(image.length, cur); @@ -24,10 +34,10 @@ export function allocateBuffer(jobId: string, code: string, image: string): Buff return buffer; } -export function getRunner(language: string): typeof RUNNERS[number] | null { +export function getRunner(language: string): (typeof RUNNERS)[number] | null { language = aliases[language] || language; if (ALLOWED_LANGUAGES.has(language)) { - return language as typeof RUNNERS[number]; + return language as (typeof RUNNERS)[number]; } return null; } diff --git a/src/server.ts b/src/server.ts index f7462b9..f8606ac 100644 --- a/src/server.ts +++ b/src/server.ts @@ -7,6 +7,8 @@ import { Pull, Push } from "zeromq"; import * as db from "./database"; +console.log(IMAGES.logo); + const sender = new Push(); await sender.bind(`tcp://127.0.0.1:5557`); const receiver = new Pull(); -- 2.36.3 From 265899ecee76da084fe5b4ec301391e8cd3d70ea Mon Sep 17 00:00:00 2001 From: "hugo.pradier2" Date: Mon, 27 May 2024 08:28:11 +0200 Subject: [PATCH 13/13] retirer le fichier database.db --- src/db/database.db | Bin 24576 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 src/db/database.db diff --git a/src/db/database.db b/src/db/database.db deleted file mode 100644 index c33d49ac73d18762af7066538a6cd165d31ee32b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24576 zcmeI)(QDH{90%~bW^LC&8$nAD9Gv*DhL&MB-=<<6QHyQ1buGFFDRH^gV47@6ItB5e z^MCLU@IUa;e`5G22)_8B;F~`9;9XeC8gb8deheI)=G!Y_ot5oG{`6 zxBK!cIjgMo8gnggFtP^x^gwf?%gkP@#ZJwTTqlPnZ83b;_ag2^tZO_LV@}5DV{I<4 zEiTd{8t0c>pVZl@Jd@ry*GZ5haYnv251oN$MUL-He}0V}@*tGm$t;tVZ7MmfTBSSj zy21ljY*G6mKNxXum#4zHsa2*!IDe$QZ-t@ww%BQoeI5**P>O_;xf7Ba>zU21p1~^dl)8Q^lhd}UlsKNvU!J6G zjUqpe`>8ee>!}X8mzVo{QWS@xekAI5^^>SjAOHafKmY;|fB*y_009U<00I!00fCZ| zC0e-<@i1DgudLoEWhU`T9Mef$m+^wgNl`x&^@sXRR45RD00bZa0SG_<0uX=z1Rwwb z2+XEHLD6XZJU~fWE17vki=PqHi|SXBQICmwjNSii-d?O40uX=z1Rwwb2tWV=5P$## z{y%|>RH@SRPyO>5rCgBzP7xlL3aPX5_y6Kg|0ocE00bZa0SG_<0uX=z1Rwwb2%KYq zWdE1*OelhG*f*!8v7zX65lJx>4t -- 2.36.3