feat: begin pieces implementation

back-end/src/controllers/piece.controller.ts

@@ -0,0 +1,154 @@
+import { Request, Response } from 'express';
+import { new_client } from '../db/db_client';
+import { Colour, Pattern, Shape, Piece, ComplexPiece } from '../types/piece';
+import { Either, eitherLeft, eitherRight } from '../utils/utils';
+
+const getDefaultColour = () => ({ id_colour: -1, name: 'unknown' });
+const getDefaultPattern = () => ({ id_pattern: -1, name: 'unknown' });
+const getDefaultShape = () => ({ id_shape: -1, name: 'unknown' });
+const getDefaultPiece = () => ({ id_piece: -1, colour: getDefaultColour(), pattern: getDefaultPattern(), shape: getDefaultShape() });
+
+async function getEntity<T>(table: string, column: string, value: string | number, f: (o: Object) => T): Promise<Either<T, string>> {
+    const client = new_client();
+    await client.connect();
+    const res = await client.query(`SELECT * FROM ${client.escapeIdentifier(table)} WHERE $1=$2;`, [column, value]);
+    if (res.rows.length === 0) {
+        await client.end();
+        return eitherRight<T, string>('Not found in database.');
+    }
+    const entity: T = f(res.rows[0]);
+    await client.end();
+    return eitherLeft<T, string>(entity);    
+}
+
+async function getEntities<T>(table: string, f: (o: Object) => T): Promise<Array<T>> {
+    const client = new_client();
+    await client.connect();
+    const res = await client.query(`SELECT * FROM ${client.escapeIdentifier(table)};`);
+    const arr: Array<T> = new Array();
+    for (let i = 0; i < res.rows.length; ++i) {
+        arr.push(f(res.rows[i]));
+    }
+    await client.end();
+    return arr;
+}
+
+const toColour: (o: Object) => Colour = o => {
+    return { id_colour: o['id_couleur'], name: o['nom_couleur'] };
+};
+
+async function getColour(idOrName: number | string): Promise<Either<Colour, string>> {
+    return await getEntity<Colour>('couleurs', typeof idOrName !== 'number' ? 'nom_couleur' : 'id_couleur', idOrName, toColour);
+}
+
+async function getColours(): Promise<Array<Colour>> {
+    return await getEntities<Colour>('couleurs', toColour);
+}
+
+async function createColour(name: string): Promise<Colour> {
+    return getDefaultColour();
+}
+
+const toPattern: (o: Object) => Pattern = o => {
+    return { id_pattern: o['id_motif'], name: o['nom_motif'] };
+};
+
+async function getPattern(idOrName: number | string): Promise<Either<Pattern, string>> {
+    return await getEntity<Pattern>('motifs', typeof idOrName !== 'number' ? 'nom_motif' : 'id_motif', idOrName, toPattern);
+}
+
+async function getPatterns(): Promise<Array<Pattern>> {
+    return await getEntities<Pattern>('motifs', toPattern);
+}
+
+async function createPattern(name: string): Promise<Pattern> {
+    return getDefaultPattern();
+}
+
+const toShape: (o: Object) => Shape = o => {
+    return { id_shape: o['id_forme'], name: o['nom_forme'] };
+};
+
+async function getShape(idOrName: number | string): Promise<Either<Shape, string>> {
+    return await getEntity<Shape>('formes', typeof idOrName !== 'number' ? 'nom_forme' : 'id_forme', idOrName, toShape);
+}
+
+async function getShapes(): Promise<Array<Shape>> {
+    return await getEntities<Shape>('formes', toShape);
+}
+
+async function createShape(name: string): Promise<Shape> {
+    return getDefaultShape();
+}
+
+async function getPiece(id: number): Promise<Piece> {
+    return getDefaultPiece();
+}
+
+async function getPieces(): Promise<Array<Piece>> {
+    return new Array(getDefaultPiece());
+}
+
+async function createPiece(colour: number, pattern: number, shape: number): Promise<Piece> {
+    return getDefaultPiece();
+}
+
+async function retrieveEntity<T>(f: (id: number) => Promise<Either<T, string>>, req: Request, res: Response) {
+    const entity: Either<T, string> = await f(parseInt(req.params.id));
+    if (entity.hasRight) {
+        res.status(500).send(entity.right);
+        return;
+    }
+    res.send(entity.left);
+}
+
+const retrieveColour = async (req: Request, res: Response) => {
+    retrieveEntity<Colour>(getColour, req, res);
+};
+
+const retrieveColours = async (req: Request, res: Response) => {
+    const colours: Array<Colour> = await getColours();
+    res.send(colours);
+};
+
+const registerColour = (req: Request, res: Response) => {
+    
+};
+
+const retrievePattern = (req: Request, res: Response) => {
+    retrieveEntity<Pattern>(getPattern, req, res);
+};
+
+const retrievePatterns = (req: Request, res: Response) => {
+    res.send(getPatterns());
+};
+
+const registerPattern = (req: Request, res: Response) => {
+    
+};
+
+const retrieveShape = (req: Request, res: Response) => {
+    retrieveEntity<Shape>(getShape, req, res);
+};
+
+const retrieveShapes = (req: Request, res: Response) => {
+    res.send(getShapes());
+};
+
+const registerShape = (req: Request, res: Response) => {
+    
+};
+
+const retrievePiece = (req: Request, res: Response) => {
+    retrieveEntity<Piece>(getPiece, req, res);
+};
+
+const retrievePieces = (req: Request, res: Response) => {
+    res.send(getPieces());
+};
+
+const registerPiece = (req: Request, res: Response) => {
+    
+};
+
+export { retrieveColour, retrieveColours, registerColour, retrievePattern, retrievePatterns, registerPattern, retrieveShape, retrieveShapes, registerShape, retrievePieces, registerPiece };

back-end/src/routes/index.ts

@@ -3,6 +3,7 @@ import db from '../db';
 import { getUsername, verifyAuthentication } from '../middlewares/auth.middleware'
 import authRoute from './auth.route'
 import marquesRoute from './marque.route'
+import piecesRoute from './piece.route'
 
 const routes = express.Router();
 
@@ -18,5 +19,6 @@ routes.get("/message", async (_req, res) => {
 
 routes.use("/auth", authRoute);
 routes.use("/marques", getUsername, verifyAuthentication, marquesRoute);
+routes.use("/pieces", getUsername, verifyAuthentication, piecesRoute);
 
 export default routes;

back-end/src/routes/piece.route.ts

@@ -0,0 +1,19 @@
+import express from 'express';
+import { retrieveColour, retrieveColours, registerColour, retrievePatterns, registerPattern, retrieveShapes, registerShape, retrievePieces, registerPiece } from '../controllers/piece.controller';
+
+const router = express.Router();
+
+router.get("/colour", retrieveColours);
+router.get("/colour/:id", retrieveColour);
+router.post("/colour/register", registerColour);
+router.get("/pattern", retrievePatterns);
+router.get("/colour/:id", retrievePattern);
+router.post("/pattern/register", registerPattern);
+router.get("/shape", retrieveShapes);
+router.get("/shape/:id", retrieveShape);
+router.post("/shape/register", registerShape);
+router.get("/", retrievePieces);
+router.get("/:id", retrievePiece);
+router.post("/register", registerPiece);
+
+export default router;

back-end/src/types/piece.ts

@@ -0,0 +1,28 @@
+type Colour = {
+    id_colour: number,
+    name: string
+};
+
+type Pattern = {
+    id_pattern: number,
+    name: string
+};
+
+type Shape = {
+    id_shape: number,
+    name: string
+};
+
+type Piece = {
+    id_piece: number,
+    colour: Colour,
+    pattern: Pattern,
+    shape: Shape
+};
+
+type ComplexPiece = {
+    id_complex: number,
+    subpieces: Array<Piece>
+};
+
+export { Colour, Pattern, Shape, Piece, ComplexPiece };