@ -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 d b = openDatabase ( ) ;
const d ata base = db . openDatabase ( ) ;
/* Créer les tables si elles n'existent pas */
createTables ( d b) ;
db . createTables ( d ata base ) ;
/* Route pour créer un utilisateur */
fastify . post < {
Body : {
login : string ;
password : string ;
permissions : number ;
} ;
} > ( "/users" , async ( request , reply ) = > {
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 ;
insertUser ( db , login , password , permissions ) ;
db . insertUser ( d ata base , 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 ) = > {
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 ;
updateUserLogin ( db , parseInt ( id ) , newLogin ) ;
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 ) = > {
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 ;
await updateUserPassword ( db , parseInt ( id ) , newPassword ) ;
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 ) = > {
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 updateUserPermissions ( db , parseInt ( id ) , newPermissions ) ;
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 ) = > {
fastify . delete (
"/users/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
await deleteUserById ( db , parseInt ( id ) ) ;
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 ) = > {
fastify . delete (
"/users/login/:login" ,
{
schema : {
params : Type.Object ( {
login : Type.String ( ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { login } = request . params ;
await deleteUserByLogin ( db , login ) ;
await db . deleteUserByLogin ( d ata base , login ) ;
reply . send ( { success : true } ) ;
} ) ;
}
) ;
/* Route pour supprimer tous les utilisateurs */
fastify . delete ( "/users" , async ( request , reply ) = > {
await d eleteAllUsers( d b) ;
await d b. d eleteAllUsers( d ata base ) ;
reply . send ( { success : true } ) ;
} ) ;
/* Route pour récupérer tous les utilisateurs */
fastify . get ( "/users" , async ( request , reply ) = > {
const users = await ( d b) ;
const users = await db. selectAllUsers( d ata base ) ;
reply . send ( users ) ;
} ) ;
/* Route pour récupérer un utilisateur par son ID */
fastify . get < {
Params : { id : string } ;
} > ( "/users/:id" , async ( request , reply ) = > {
fastify . get (
"/users/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
const user = await selectUserById ( db , parseInt ( id ) ) ;
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 ) = > {
fastify . get (
"/users/login/:login" ,
{
schema : {
params : Type.Object ( {
login : Type.String ( ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { login } = request . params ;
const user = await selectUserByLogin ( db , login ) ;
const user = await db. selectUserByLogin( d ata base , login ) ;
reply . send ( user ) ;
} ) ;
}
) ;
/* Route pour créer un language */
fastify . post < {
Body : {
designation : string ;
version : string ;
} ;
} > ( "/languages" , async ( request , reply ) = > {
fastify . post (
"/languages" ,
{
schema : {
body : Type.Object ( {
designation : Type.String ( ) ,
version : Type.Number ( ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { designation , version } = request . body ;
insertLanguage ( db , designation , parseInt ( version ) ) ;
db . insertLanguage ( d ata base , 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 ) = > {
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 ;
updateLanguageDesignation ( db , parseInt ( id ) , newDesignation ) ;
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 ) = > {
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 ;
updateLanguageVersion ( db , parseInt ( id ) , newVersion ) ;
db . updateLanguageVersion ( database , id , newVersion ) ;
reply . send ( { success : true } ) ;
} ) ;
}
) ;
/* Route pour supprimer un language */
fastify . delete < {
Params : { id : string } ;
} > ( "/languages/:id" , async ( request , reply ) = > {
fastify . delete (
"/languages/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
deleteLanguage ( db , parseInt ( id ) ) ;
db . deleteLanguage ( database , id ) ;
reply . send ( { success : true } ) ;
} ) ;
}
) ;
/* Route pour supprimer tous les languages */
fastify . delete ( "/languages" , async ( request , reply ) = > {
deleteAllLanguages ( db ) ;
d b. d eleteAllLanguages( d ata base ) ;
reply . send ( { success : true } ) ;
} ) ;
/* Route pour récupérer un language par son ID */
fastify . get < {
Params : { id : string } ;
} > ( "/languages/:id" , async ( request , reply ) = > {
fastify . get (
"/languages/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
const language = await selectLanguageById ( db , parseInt ( id ) ) ;
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( d ata base ) ;
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 ) = > {
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 ;
insertWork ( db , link , id_user , id_language , code ) ;
db . insertWork ( d ata base , 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 ( d b) ;
const works = await db. selectAllWorks( d ata base ) ;
reply . send ( works ) ;
} ) ;
/* Route pour supprimer tous les works */
fastify . delete ( "/works" , async ( request , reply ) = > {
d eleteAllWorks( d b) ;
d b. d eleteAllWorks( d ata base ) ;
reply . send ( { success : true } ) ;
} ) ;
/* Route pour supprimer un work par son ID */
fastify . delete < {
Params : { id : string } ;
} > ( "/works/:id" , async ( request , reply ) = > {
fastify . delete (
"/works/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
deleteWork ( db , parseInt ( id ) ) ;
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 ) = > {
fastify . get (
"/works/:id" ,
{
schema : {
params : Type.Object ( {
id : Type.Number ( {
minimum : 0 ,
} ) ,
} ) ,
} ,
} ,
async ( request , reply ) = > {
const { id } = request . params ;
const work = await selectWorkById ( db , parseInt ( id ) ) ;
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() {
