renamed leftover references to bookApi

backend_splatournament_manager/src/app.ts

@@ -13,25 +13,25 @@ const app = express();
 app.use(bodyParser.json());
 app.use(router);
 
-app.get('/tournaments/available', async (req: Request, res: Response) => {
+app.get('/tournaments', async (req: Request, res: Response) => {
     console.log(req.params)
     if (!req.params.id) {
         const tournaments = await tournamentService.getAllTournaments();
         console.log(tournaments)
         return res.send(tournaments);
     }
-    const tournament = await tournamentService.getBookById(+req.params.id);
+    const tournament = await tournamentService.getTournamentById(+req.params.id);
     if (!tournament) {
-        return res.status(404).send({error: 'Book not found'});
+        return res.status(404).send({error: 'Tournament not found'});
     }
     res.send(tournament);
 });
 
-app.post('/books', async (req: Request, res: Response) => {
+app.post('/tournaments', async (req: Request, res: Response) => {
     console.log("post");
     
     try {
-        await tournamentService.addBook(req.body);
+        await tournamentService.addTournament(req.body);
         res.status(200).send();
     }catch (err){
         console.log(err);
@@ -39,28 +39,28 @@ app.post('/books', async (req: Request, res: Response) => {
     }
 });
 
-app.put('/books', async (req: Request, res: Response) => {
+app.put('/tournaments', async (req: Request, res: Response) => {
     if (!req.query.id) {
         return res.status(400).send({error: 'Missing id parameter'});
     }
     try {
-        const success = await tournamentService.updateBook(+req.query.id!, req.body);
+        const success = await tournamentService.updateTournament(+req.query.id!, req.body);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to update book'});
+        return res.status(400).send({error: 'Failed to update Tournament'});
     }
-    res.status(200).send({message: 'Book updated successfully'});
+    res.status(200).send({message: 'Tournament updated successfully'});
 });
 
-app.delete('/books', async (req: Request, res: Response) => {
+app.delete('/tournaments', async (req: Request, res: Response) => {
     if (!req.query.id) {
         return res.status(400).send({error: 'Missing id parameter'});
     }
     try {
-        const success = await tournamentService.deleteBook(+req.query.id!);
+        const success = await tournamentService.deleteTournament(+req.query.id!);
     } catch (err) {
-        return res.status(400).send({error: 'Failed to delete book'});
+        return res.status(400).send({error: 'Failed to delete Tournament'});
     }
-    res.status(200).send({message: 'Book deleted successfully'});
+    res.status(200).send({message: 'Tournament deleted successfully'});
 });
 
 app.listen(port, () => {

backend_splatournament_manager/src/services/tournament-service.ts

@@ -9,34 +9,89 @@ export class TournamentService {
     private db: Database;
 
     constructor() {
+        if (fs.existsSync(this.dbFilename)) {
             fs.unlinkSync(this.dbFilename);
+        }
         this.db = new Database(this.dbFilename);
         this.db.serialize(() => {
             this.db.run(`CREATE TABLE IF NOT EXISTS Tournaments
                          (
-                             id
+                             id                INTEGER PRIMARY KEY AUTOINCREMENT,
-                                 INTEGER
+                             name              TEXT,
-                                 PRIMARY
+                             description       TEXT,
-                                     KEY
+                             maxTeamAmount     INTEGER,
-                                 AUTOINCREMENT,
+                             currentTeamAmount INTEGER
-                             name
-                                 TEXT,
-                             description
-                                 TEXT,
-                             maxTeamAmount
-                                 INTEGER,
-                             currentTeamAmount
-                                 INTEGER
                          )`);
         })
         this.seedDb();
     }
 
+    getAllTournaments(): Promise<Tournament[]> {
+        return new Promise<Tournament[]>((resolve, reject) => {
+            this.db.all(`SELECT *
+                         FROM Tournaments`, (err: RunResult, rows: Tournament[]) => {
+                if (!err) {
+                    resolve(rows);
+                }
+                reject(err);
+            });
+        });
+    }
+
+    getTournamentById(id: number): Promise<Tournament> {
+        return new Promise<Tournament>((resolve, reject) => {
+            this.db.get(`Select *
+                         From Tournaments
+                         WHERE id = ${id}`, (err: RunResult, tournament: Tournament) => {
+                if (!err) {
+                    resolve(tournament);
+                }
+                reject(err);
+            });
+        })
+    }
+
+    addTournament(tournament: Tournament): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            const statement = this.db.prepare('Insert Into Tournaments (name, description, maxTeamAmount, currentTeamAmount) VALUES (?, ?, ?, ?)')
+            statement.run(tournament.name, tournament.description, tournament.maxTeamAmount, tournament.currentTeamAmount);
+            resolve();
+        })
+    }
+
+    updateTournament(id: number, updatedTournament: Tournament): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.db.run(`Update Tournaments
+                         Set name              = $name,
+                             description       = $description,
+                             maxTeamAmount     = $maxTeamAmount,
+                             currentTeamAmount = $currentTeamAmount
+                         where id = $id`, {
+                $id: id,
+                $description: updatedTournament.description,
+                $maxTeamAmount: updatedTournament.maxTeamAmount,
+                $currentTeamAmount: updatedTournament.currentTeamAmount,
+            });
+            resolve();
+        })
+    }
+
+    deleteTournament(id: number): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.db.run('Delete From Tournaments where id = $id', {
+                $id: id,
+            });
+            resolve();
+        })
+    }
+
     private seedDb() {
         fs.readFile(path.join(process.cwd(), "dist", this.csvFilename), 'utf-8', (_, data) => {
             const entries = data.split('\n');
             entries.shift();
-            const statement = this.db.prepare("INSERT INTO Tournaments ( name, description, maxTeamAmount, currentTeamAmount) VALUES (?, ?, ?, ?)");
+            const statement = this.db.prepare(`INSERT INTO Tournaments
+                                                   (name, description, maxTeamAmount, currentTeamAmount)
+                                               VALUES (?, ?, ?, ?)`);
             entries.forEach(line => {
                 if (line) {
                     const parts = line.split(',');
@@ -54,65 +109,4 @@ export class TournamentService {
             statement.finalize();
         });
     }
-
-    getAllTournaments(): Promise<Tournament[]> {
-        return new Promise<Tournament[]>((resolve, reject) => {
-            this.db.all(`SELECT *
-                         FROM Tournaments`,
-                (err: RunResult, rows: Tournament[]) => {
-                    if (!err) {
-                        resolve(rows);
-                    }
-                    reject(err);
-                });
-        });
-    }
-
-    getBookById(id: number): Promise<Tournament> {
-        return new Promise<Tournament>((resolve, reject) => {
-            this.db.get(`Select *
-                         From Tournaments
-                         WHERE id = ${id}`, (err: RunResult, book: Tournament) => {
-                if (!err) {
-                    resolve(book);
-                }
-                reject(err);
-            });
-        })
-    }
-
-    addBook(tournament: Tournament): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            const statement = this.db.prepare('Insert Into Tournaments (name, description, maxTeamAmount, currentTeamAmount) VALUES (?, ?, ?, ?)')
-            statement.run(tournament.name, tournament.description, tournament.maxTeamAmount, tournament.currentTeamAmount);
-            resolve();
-        })
-    }
-
-    updateBook(id: number, updatedBook: Tournament): Promise<void> {
-        return new Promise((resolve, reject) => {
-            this.db.run(`Update Tournaments
-                         Set name  = $name,
-                             description = $description,
-                             maxTeamAmount = $maxTeamAmount,
-                             currentTeamAmount   = $currentTeamAmount
-                         where id = $id`,
-                {
-                    $id: id,
-                    $description: updatedBook.description,
-                    $maxTeamAmount: updatedBook.maxTeamAmount,
-                    $currentTeamAmount: updatedBook.currentTeamAmount,
-                });
-            resolve();
-        })
-    }
-
-    deleteBook(id: number): Promise<void> {
-        return new Promise((resolve, reject) => {
-            this.db.run('Delete From Tournaments where id = $id', {
-                $id: id,
-            });
-            resolve();
-        })
-    }
 }