sandkasten
/
labyrinth
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ajout du champ link a Work + methode supprimer user par login + revu des commentaires
continuous-integration/drone/push Build is passing Details
continuous-integration/drone/pr Build is failing Details

Browse Source
pull/2/head
Hugo PRADIER 11 months ago
parent 7c65066ca9
commit 09842511b8
3 changed files with 100 additions and 70 deletions
Show Stats Download Patch File Download Diff File

90
src/database.ts
Unescape View File

@ -4,8 +4,9 @@ import fs from "fs";
const dbDirectory = "./src/db"; const dbDirectory = "./src/db";
const dbFilePath = `${dbDirectory}/database.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( function runDB(
db: sqlite3.Database, db: sqlite3.Database,
query: string, 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<any[]> { function allDB(db: sqlite3.Database, query: string): Promise<any[]> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
db.all(query, (err, rows) => { db.all(query, (err, rows) => {
@ -34,13 +36,14 @@ function allDB(db: sqlite3.Database, query: string): Promise<any[]> {
}); });
} }
/* Fonction pour récupérer une seule ligne de la base de données */
function getDB( function getDB(
db: sqlite3.Database, db: sqlite3.Database,
query: string, query: string,
params: any[] params: any[]
): Promise<void> { ): Promise<void> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
db.get(query, params, (err, row : any) => { db.get(query, params, (err, row: any) => {
if (err) { if (err) {
reject(err); reject(err);
} else { } 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() { function createDbDirectory() {
if (!fs.existsSync(dbDirectory)) { if (!fs.existsSync(dbDirectory)) {
fs.mkdirSync(dbDirectory); fs.mkdirSync(dbDirectory);
} }
} }
// Ouvrir la base de données /* Ouvrir la base de données */
function openDatabase() { function openDatabase() {
console.log("Ouverture de la connexion à la base de données."); console.log("Ouverture de la connexion à la base de données.");
return new sqlite3.Database( 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) { function closeDatabase(db: sqlite3.Database) {
db.close((err) => { db.close((err) => {
if (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) { function createTables(db: sqlite3.Database) {
createRegisteredUserTable(db); createRegisteredUserTable(db);
createLanguageTable(db); createLanguageTable(db);
@ -97,14 +100,14 @@ function createTables(db: sqlite3.Database) {
// UNIQUE (login) // 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<void> { function createRegisteredUserTable(db: sqlite3.Database): Promise<void> {
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))`;
return runDB(db, tableRegisteredUser, []); return runDB(db, tableRegisteredUser, []);
} }
// Insérer un utilisateur dans la table registered_user /* Insérer un utilisateur dans la table registered_user */
function insertUser( function insertUser(
db: sqlite3.Database, db: sqlite3.Database,
login: string, login: string,
@ -116,14 +119,14 @@ function insertUser(
return runDB(db, insertUserQuery, [login, password, permissions]); 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) { function updateUserLogin(db: sqlite3.Database, id: number, newLogin: string) {
const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`; const updateUserLoginQuery = `UPDATE registered_user SET login = ? WHERE id_user = ?`;
return runDB(db, updateUserLoginQuery, [newLogin, id]); 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( function updateUserPassword(
db: sqlite3.Database, db: sqlite3.Database,
id: number, id: number,
@ -134,6 +137,7 @@ function updateUserPassword(
return runDB(db, updateUserPasswordQuery, [newPassword, id]); return runDB(db, updateUserPasswordQuery, [newPassword, id]);
} }
/* Modifier les permissions d'un utilisateur dans la table registered_user */
function updateUserPermissions( function updateUserPermissions(
db: sqlite3.Database, db: sqlite3.Database,
id: number, id: number,
@ -144,35 +148,42 @@ function updateUserPermissions(
return runDB(db, updateUserPermissionsQuery, [newPermissions, id]); return runDB(db, updateUserPermissionsQuery, [newPermissions, id]);
} }
// Supprimer un utilisateur de la table registered_user /* Supprimer un utilisateur de la table registered_user par son ID */
function deleteUser(db: sqlite3.Database, id: number) { function deleteUserById(db: sqlite3.Database, id: number) {
const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`; const deleteUserQuery = `DELETE FROM registered_user WHERE id_user = ?`;
return runDB(db, deleteUserQuery, [id]); 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) { function deleteAllUsers(db: sqlite3.Database) {
const deleteAllUsersQuery = `DELETE FROM registered_user`; const deleteAllUsersQuery = `DELETE FROM registered_user`;
return runDB(db, deleteAllUsersQuery, []); 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<unknown[]> { function selectAllUsers(db: sqlite3.Database): Promise<unknown[]> {
const selectAllUsersQuery = `SELECT * FROM registered_user`; const selectAllUsersQuery = `SELECT * FROM registered_user`;
return allDB(db, selectAllUsersQuery); 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) { function selectUserByLogin(db: sqlite3.Database, login: string) {
const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`; const selectUserByLoginQuery = `SELECT * FROM registered_user WHERE login = ?`;
return getDB(db, selectUserByLoginQuery, [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) { function selectUserById(db: sqlite3.Database, id: number) {
const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`; const selectUserByIdQuery = `SELECT * FROM registered_user WHERE id_user = ?`;
@ -186,13 +197,13 @@ function selectUserById(db: sqlite3.Database, id: number) {
// version INT NOT NULL, // 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<void> { function createLanguageTable(db: sqlite3.Database): Promise<void> {
const tableLanguage = `CREATE TABLE IF NOT EXISTS language (id_language INTEGER PRIMARY KEY AUTOINCREMENT, designation TEXT NOT NULL, version INTEGER NOT NULL)`; 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, []); return runDB(db, tableLanguage, []);
} }
// Insérer un language dans la table language /* Insérer un language dans la table language */
function insertLanguage( function insertLanguage(
db: sqlite3.Database, db: sqlite3.Database,
designation: string, designation: string,
@ -203,14 +214,18 @@ function insertLanguage(
return runDB(db, insertLanguageQuery, [designation, version]); return runDB(db, insertLanguageQuery, [designation, version]);
} }
// Modifier la designation d'un language dans la table language /* Modifier la designation d'un language dans la table language */
function updateLanguageDesignation(db: sqlite3.Database, id: number, newDesignation: string) { function updateLanguageDesignation(
db: sqlite3.Database,
id: number,
newDesignation: string
) {
const updateLanguageDesignationQuery = `UPDATE language SET designation = ? WHERE id_language = ?`; const updateLanguageDesignationQuery = `UPDATE language SET designation = ? WHERE id_language = ?`;
return runDB(db, updateLanguageDesignationQuery, [newDesignation, id]); 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( function updateLanguageVersion(
db: sqlite3.Database, db: sqlite3.Database,
id: number, id: number,
@ -221,28 +236,28 @@ function updateLanguageVersion(
return runDB(db, updateLanguageVersionQuery, [newVersion, id]); 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) { function deleteLanguage(db: sqlite3.Database, id: number) {
const deleteLanguageQuery = `DELETE FROM language WHERE id_language = ?`; const deleteLanguageQuery = `DELETE FROM language WHERE id_language = ?`;
return runDB(db, deleteLanguageQuery, [id]); 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) { function deleteAllLanguages(db: sqlite3.Database) {
const deleteAllLanguagesQuery = `DELETE FROM language`; const deleteAllLanguagesQuery = `DELETE FROM language`;
return runDB(db, deleteAllLanguagesQuery, []); 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<unknown[]> { function selectAllLanguages(db: sqlite3.Database): Promise<unknown[]> {
const selectAllLanguagesQuery = `SELECT * FROM language`; const selectAllLanguagesQuery = `SELECT * FROM language`;
return allDB(db, selectAllLanguagesQuery); 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) { function selectLanguageById(db: sqlite3.Database, id: number) {
const selectLanguageByIdQuery = `SELECT * FROM language WHERE id_language = ?`; const selectLanguageByIdQuery = `SELECT * FROM language WHERE id_language = ?`;
@ -252,51 +267,53 @@ function selectLanguageById(db: sqlite3.Database, id: number) {
/////////////////////////// Gestion des works /////////////////////////// /////////////////////////// Gestion des works ///////////////////////////
// CREATE TABLE work ( // CREATE TABLE work (
// id_work SERIAL PRIMARY KEY, // id_work SERIAL PRIMARY KEY,
// link CHAR(36) NOT NULL,
// user_id INT REFERENCES registered_user(id_user), // user_id INT REFERENCES registered_user(id_user),
// language_id INT NOT NULL REFERENCES language(id_language) // 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<void> { function createWorkTable(db: sqlite3.Database): Promise<void> {
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, []); return runDB(db, tableWork, []);
} }
// Insérer un work dans la table work /* Insérer un work dans la table work */
function insertWork( function insertWork(
db: sqlite3.Database, db: sqlite3.Database,
link: string,
user_id: number, user_id: number,
language_id: number, language_id: number,
content: string 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<unknown[]> { function selectAllWorks(db: sqlite3.Database): Promise<unknown[]> {
const selectAllWorksQuery = `SELECT * FROM work`; const selectAllWorksQuery = `SELECT * FROM work`;
return allDB(db, selectAllWorksQuery); 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) { function deleteAllWorks(db: sqlite3.Database) {
const deleteAllWorksQuery = `DELETE FROM work`; const deleteAllWorksQuery = `DELETE FROM work`;
return runDB(db, deleteAllWorksQuery, []); 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) { function deleteWork(db: sqlite3.Database, id: number) {
const deleteWorkQuery = `DELETE FROM work WHERE id_work = ?`; const deleteWorkQuery = `DELETE FROM work WHERE id_work = ?`;
return runDB(db, deleteWorkQuery, [id]); 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) { function selectWorkById(db: sqlite3.Database, id: number) {
const selectWorkByIdQuery = `SELECT * FROM work WHERE id_work = ?`; const selectWorkByIdQuery = `SELECT * FROM work WHERE id_work = ?`;
@ -313,7 +330,8 @@ export {
updateUserLogin, updateUserLogin,
updateUserPassword, updateUserPassword,
updateUserPermissions, updateUserPermissions,
deleteUser, deleteUserById,
deleteUserByLogin,
deleteAllUsers, deleteAllUsers,
selectAllUsers, selectAllUsers,
selectUserByLogin, selectUserByLogin,

BIN
src/db/database.db
View File

Binary file not shown.

78
src/server.ts
Unescape View File

@ -14,7 +14,8 @@ import {
updateUserLogin, updateUserLogin,
updateUserPassword, updateUserPassword,
updateUserPermissions, updateUserPermissions,
deleteUser, deleteUserById,
deleteUserByLogin,
deleteAllUsers, deleteAllUsers,
selectAllUsers, selectAllUsers,
selectUserByLogin, selectUserByLogin,
@ -48,9 +49,9 @@ await fastify.register(cors, {
origin: process.env.ALLOW_ORIGIN || "*", origin: process.env.ALLOW_ORIGIN || "*",
}); });
// Code runner in a container /* Code runner in a container */
// POST /run : Run code in a container /* POST /run : Run code in a container */
fastify.post( fastify.post(
"/run", "/run",
@ -84,18 +85,18 @@ fastify.post(
} }
); );
// Database /* Database */
// Création du répertoire de la base de données s'il n'existe pas /* Création du répertoire de la base de données s'il n'existe pas */
createDbDirectory(); createDbDirectory();
// Ouvrir la base de données /* Ouvrir la base de données */
const db = openDatabase(); const db = openDatabase();
// Créer les tables si elles n'existent pas /* Créer les tables si elles n'existent pas */
createTables(db); createTables(db);
// Route pour créer un utilisateur /* Route pour créer un utilisateur */
fastify.post<{ fastify.post<{
Body: { Body: {
login: string; login: string;
@ -108,7 +109,7 @@ fastify.post<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour mettre à jour le login d'un utilisateur /* Route pour mettre à jour le login d'un utilisateur */
fastify.put<{ fastify.put<{
Params: { id: string }; Params: { id: string };
Body: { newLogin: string }; Body: { newLogin: string };
@ -119,7 +120,7 @@ fastify.put<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour mettre à jour le mot de passe d'un utilisateur /* Route pour mettre à jour le mot de passe d'un utilisateur */
fastify.put<{ fastify.put<{
Params: { id: string }; Params: { id: string };
Body: { newPassword: string }; Body: { newPassword: string };
@ -130,7 +131,7 @@ fastify.put<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour mettre à jour les permissions d'un utilisateur /* Route pour mettre à jour les permissions d'un utilisateur */
fastify.put<{ fastify.put<{
Params: { id: string }; Params: { id: string };
Body: { newPermissions: number }; Body: { newPermissions: number };
@ -141,27 +142,37 @@ fastify.put<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour supprimer un utilisateur /* Route pour supprimer un utilisateur par son ID */
fastify.delete<{ fastify.delete<{
Params: { id: string }; Params: { id: string };
}>("/users/:id", async (request, reply) => { }>("/users/:id", async (request, reply) => {
const { id } = request.params; const { id } = request.params;
await deleteUser(db, parseInt(id)); await deleteUserById(db, parseInt(id));
reply.send({ success: true }); 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) => { fastify.delete("/users", async (request, reply) => {
await deleteAllUsers(db); await deleteAllUsers(db);
reply.send({ success: true }); 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) => { fastify.get("/users", async (request, reply) => {
const users = await selectAllUsers(db); const users = await selectAllUsers(db);
reply.send(users); 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<{ fastify.get<{
Params: { id: string }; Params: { id: string };
}>("/users/:id", async (request, reply) => { }>("/users/:id", async (request, reply) => {
@ -170,7 +181,7 @@ fastify.get<{
reply.send(user); 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<{ fastify.get<{
Params: { login: string }; Params: { login: string };
}>("/users/login/:login", async (request, reply) => { }>("/users/login/:login", async (request, reply) => {
@ -179,7 +190,7 @@ fastify.get<{
reply.send(user); reply.send(user);
}); });
// Route pour créer un language /* Route pour créer un language */
fastify.post<{ fastify.post<{
Body: { Body: {
designation: string; designation: string;
@ -191,7 +202,7 @@ fastify.post<{
reply.send({ success: true }); 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<{ fastify.put<{
Params: { id: string }; Params: { id: string };
Body: { newDesignation: string }; Body: { newDesignation: string };
@ -202,7 +213,7 @@ fastify.put<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour mettre à jour la version d'un language /* Route pour mettre à jour la version d'un language */
fastify.put<{ fastify.put<{
Params: { id: string }; Params: { id: string };
Body: { newVersion: number }; Body: { newVersion: number };
@ -213,7 +224,7 @@ fastify.put<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour supprimer un language /* Route pour supprimer un language */
fastify.delete<{ fastify.delete<{
Params: { id: string }; Params: { id: string };
}>("/languages/:id", async (request, reply) => { }>("/languages/:id", async (request, reply) => {
@ -222,13 +233,13 @@ fastify.delete<{
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour supprimer tous les languages /* Route pour supprimer tous les languages */
fastify.delete("/languages", async (request, reply) => { fastify.delete("/languages", async (request, reply) => {
deleteAllLanguages(db); deleteAllLanguages(db);
reply.send({ success: true }); 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<{ fastify.get<{
Params: { id: string }; Params: { id: string };
}>("/languages/:id", async (request, reply) => { }>("/languages/:id", async (request, reply) => {
@ -237,38 +248,39 @@ fastify.get<{
reply.send(language); 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) => { fastify.get("/languages", async (request, reply) => {
const languages = await selectAllLanguages(db); const languages = await selectAllLanguages(db);
reply.send(languages); reply.send(languages);
}); });
// Route pour créer un work /* Route pour créer un work */
fastify.post<{ fastify.post<{
Body: { Body: {
id_user: number; id_user: number;
link: string;
id_language: number; id_language: number;
code: string; code: string;
}; };
}>("/works", async (request, reply) => { }>("/works", async (request, reply) => {
const { id_user, id_language, code } = request.body; const { id_user, link, id_language, code } = request.body;
insertWork(db, id_user, id_language, code); insertWork(db, link, id_user, id_language, code);
reply.send({ success: true }); 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) => { fastify.get("/works", async (request, reply) => {
const works = await selectAllWorks(db); const works = await selectAllWorks(db);
reply.send(works); reply.send(works);
}); });
// Route pour supprimer tous les works /* Route pour supprimer tous les works */
fastify.delete("/works", async (request, reply) => { fastify.delete("/works", async (request, reply) => {
deleteAllWorks(db); deleteAllWorks(db);
reply.send({ success: true }); reply.send({ success: true });
}); });
// Route pour supprimer un work /* Route pour supprimer un work par son ID */
fastify.delete<{ fastify.delete<{
Params: { id: string }; Params: { id: string };
}>("/works/:id", async (request, reply) => { }>("/works/:id", async (request, reply) => {
@ -277,7 +289,7 @@ fastify.delete<{
reply.send({ success: true }); 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<{ fastify.get<{
Params: { id: string }; Params: { id: string };
}>("/works/:id", async (request, reply) => { }>("/works/:id", async (request, reply) => {
@ -286,8 +298,7 @@ fastify.get<{
reply.send(work); 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() { async function forwardOutput() {
for await (const [buff] of receiver) { for await (const [buff] of receiver) {
const messageType = buff.readInt8(); 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()]); await Promise.all([fastify.listen({ port: 3000 }), forwardOutput()]);

Write Preview
Loading…
Cancel
Save