implemented task 3

requests.http

@@ -0,0 +1,14 @@
+PUT http://localhost:3000/api/passengers/123456789
+Content-Type: application/json
+
+{
+  "name": "John Doe",
+  "dateOfBirth": "1990-01-01T00:00:00.000Z",
+  "isFemale": false
+}
+
+### get all
+GET http://localhost:3000/api/passengers/
+
+### get one
+GET http://localhost:3000/api/passengers/123456789

src/app.ts

@@ -1,9 +1,11 @@
 import express, {json} from 'express';
 import flightRouter from "./routes/flight.router";
+import passengerRouter from "./routes/passenger.router";
 
 const app = express();
 app.use(json())
 app.use('/api/flights', flightRouter)
+app.use('/api/passengers', passengerRouter)
 
 
 app.listen(3000, () => {

src/routes/passenger.router.ts

@@ -0,0 +1,56 @@
+import express, {Request, Response, Router} from "express";
+import {PassengerModel} from "../models/passenger.model";
+import {StatusCodes} from "http-status-codes";
+import {PassengerService} from "../services/passenger.service";
+
+const router: Router = express.Router();
+
+
+router.put('/:ssn', async (request: Request<{ ssn: string }, PassengerModel>, response: Response): Promise<void> => {
+    const ssn: string = request.params.ssn;
+    const passenger: PassengerModel = request.body;
+
+    if (typeof passenger.dateOfBirth === "string") {  //warning because of type loss at run time
+        passenger.dateOfBirth = new Date(Date.parse(passenger.dateOfBirth));
+    }
+
+    if (ssn === undefined || ssn.length != 9) {
+        response.sendStatus(StatusCodes.BAD_REQUEST);
+        return;
+    }
+    passenger.ssn = ssn;
+
+    await PassengerService.updateOrCreate(passenger)
+
+    response.sendStatus(StatusCodes.OK);
+})
+
+router.get('/', async (request: Request, response: Response): Promise<void> => {
+    const passengers: PassengerModel[] = await PassengerService.getAll();
+    response.status(StatusCodes.OK).json(passengers);
+    return;
+});
+
+
+router.get('/:ssn', async (request: Request<{
+    ssn: string | undefined
+}, PassengerModel>, response: Response): Promise<void> => {
+    const ssn: string | undefined = request.params.ssn;
+
+    if (ssn === undefined || ssn.length != 9) {
+        response.sendStatus(StatusCodes.BAD_REQUEST);
+        return;
+    }
+
+    const passanger: PassengerModel | null = await PassengerService.getOne(ssn);
+
+    if (passanger === null) {
+        response.sendStatus(StatusCodes.NO_CONTENT);
+        return;
+    }
+
+    response.status(StatusCodes.OK).json(passanger);
+    return;
+});
+
+export default router;

src/services/passenger.service.ts

@@ -0,0 +1,52 @@
+import {PassengerModel} from "../models/passenger.model";
+import {ServiceBase} from "./serviceBase";
+
+export class PassengerService extends ServiceBase {
+    static async create(passenger: PassengerModel): Promise<boolean> {
+        const sql = `INSERT INTO Passenger (ssn, name, dateOfBirth, isFemale) VALUES (?1, ?2, ?3, ?4)`;
+        const params = {
+            1: passenger.ssn,
+            2: passenger.name,
+            3: passenger.dateOfBirth.toISOString(),
+            4: passenger.isFemale
+        };
+        return await this.run(sql, params, 1);
+    }
+
+    static async update(passenger : PassengerModel) : Promise<boolean>{
+        const sql = `update Passenger set name = ?1, dateOfBirth = ?2, isFemale = ?3 where ssn = ?4`;
+        const params = {
+            1: passenger.name,
+            2: passenger.dateOfBirth.toISOString(),
+            3: passenger.isFemale,
+            4: passenger.ssn
+        };
+
+        return await this.run(sql, params, 1);
+    }
+
+    static async getOne(ssn : string) : Promise<PassengerModel | null>{
+        const sql = `select ssn, name, dateOfBirth, isFemale from Passenger where ssn = ?1;`
+        const params = {
+            1: ssn
+        }
+        return await this.get<PassengerModel>(sql, params);
+    }
+
+    static async getAll() : Promise<PassengerModel[]>{
+        const sql = `select ssn, name, dateOfBirth, isFemale from Passenger;`
+        return await this.all<PassengerModel>(sql);
+
+    }
+
+    static async updateOrCreate(passenger : PassengerModel) : Promise<void>{
+        const dbPassenger = await this.getOne(passenger.ssn);
+        if(dbPassenger === null)
+        {
+            await this.create(passenger);
+        }
+        else{
+            await this.update(passenger);
+        }
+    }
+}

src/services/serviceBase.ts

@@ -0,0 +1,42 @@
+import {Unit} from "../database/unit";
+import {ISqlite, Statement} from "sqlite";
+import RunResult = ISqlite.RunResult;
+
+export class ServiceBase {
+    public static async run(sql: string, params: any, changes: number): Promise<boolean> {
+        const unit: Unit = await Unit.create(false);
+        try {
+            const smt: Statement = await unit.prepare(sql, params);
+
+            const result: RunResult = await smt.run();
+
+            if (result.changes == undefined || result.changes != changes) {
+                await unit.complete(false);
+                return false;
+            }
+
+            await unit.complete(true)
+            return true;
+        } catch (e) {
+            await unit.complete(false)
+            console.error(e);
+            return false;
+        }
+    }
+
+    public static async get<T>(sql: string, params: any): Promise<T | null> {
+        const unit: Unit = await Unit.create(false);
+        const smt: Statement = await unit.prepare(sql, params);
+        const result = await smt.get<T>();
+        await unit.complete(true);
+        return result ?? null;
+    }
+
+    public static async all<T>(sql: string): Promise<T[]> {
+        const unit: Unit = await Unit.create(false);
+        const smt: Statement = await unit.prepare(sql);
+        const result = await smt.all<T[]>();
+        await unit.complete(true);
+        return result;
+    }
+}