From ffd23217dadcea8bed6109ba820cf21fb5484341 Mon Sep 17 00:00:00 2001
From: Alex <alex@piqueras.me>
Date: Mon, 2 Dec 2024 11:10:01 +0100
Subject: [PATCH] Add controllers

---
 src/controllers/booking.controller.ts  |  90 ++++++++++++++++++
 src/controllers/client.controller.ts   | 125 +++++++++++++++++++++++++
 src/controllers/hotel.controller.ts    | 119 +++++++++++++++++++++++
 src/repositories/booking.repository.ts |   9 +-
 src/repositories/client.repository.ts  |   4 +-
 src/repositories/hotel.repository.ts   |   4 +-
 6 files changed, 341 insertions(+), 10 deletions(-)

diff --git a/src/controllers/booking.controller.ts b/src/controllers/booking.controller.ts
index e69de29..2adb120 100644
--- a/src/controllers/booking.controller.ts
+++ b/src/controllers/booking.controller.ts
@@ -0,0 +1,90 @@
+import { Request, Response } from "express";
+
+import Booking from "../models/booking.model";
+import BookingRepository from "../repositories/booking.repository";
+
+export default class BookingController {
+  async create(req: Request, res Response) {
+    if (!req.body.hotelId || !req.body.clientId) {
+      res.status(400).json({
+        message: "Content cannot be empty"
+      });
+    }
+
+    const booking = {
+      hotelId: req.body.hotelId,
+      clientId: req.body.clientId,
+    };
+
+    try {
+      const booking = await BookingRepository.create(booking);
+      res.status(201).json(booking);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!"
+      });
+    }
+  }
+
+  async findAll(req: Request, res Response) {
+    try {
+      const bookings = await BookingRepository.retrieveAll();
+      res.status(200).json(bookings);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async findOne(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      const booking = await BookingRepository.retrieveById(req.body.id);
+      res.status(200).json(booking);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async update(req: Request, res Response) {
+    res.status(405).json({
+      message: "Cannot update booking"
+    });
+  }
+
+  async delete(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      await BookingRepository.delete(req.body.id);
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async deleteAll(req: Request, res Response) {
+    try {
+      await BookingRepository.deleteAll();
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+}
diff --git a/src/controllers/client.controller.ts b/src/controllers/client.controller.ts
index e69de29..5a2ec4c 100644
--- a/src/controllers/client.controller.ts
+++ b/src/controllers/client.controller.ts
@@ -0,0 +1,125 @@
+import { Request, Response } from "express";
+
+import Client from "../models/client.model";
+import ClientRepository from "../repositories/client.repository";
+
+export default class ClientController {
+  async create(req: Request, res Response) {
+    if (!req.body.name || !req.body.address || !req.body.phone) {
+      res.status(400).json({
+        message: "Content cannot be empty"
+      });
+    }
+
+    const client = {
+      name: req.body.name,
+      address: req.body.address,
+      phone: req.body.phone,
+    };
+
+    try {
+      const client = await ClientRepository.create(client);
+      res.status(201).json(client);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!"
+      });
+    }
+  }
+
+  async findAll(req: Request, res Response) {
+    const name = req.query.name;
+    const address = req.query.address;
+    const phone = req.query.phone;
+
+    try {
+      const clients = await ClientRepository.retrieveAll({name, address, phone});
+      res.status(200).json(clients);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async findOne(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      const client = await ClientRepository.retrieveById(req.body.id);
+      res.status(200).json(client);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async update(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    if (!req.body.name && !req.body.address && !req.body.phone) {
+      res.status(400).json({
+        message: "Content cannot be empty"
+      });
+    }
+
+    try {
+      const client = await clientRepository.retrieveById(id);
+
+      if (req.body.name) {
+        client.name = req.body.name;
+      }
+      
+      if (req.body.address) {
+        client.name = req.body.address;
+      }
+
+      if (req.body.address) {
+        client.phone = req.body.phone;
+      }
+
+      await clientRepository.update(client);
+    } catch (err) {
+      res.status(404).json({
+        message: err || "Not found"
+      });
+    }
+  }
+
+  async delete(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      await ClientRepository.delete(req.body.id);
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async deleteAll(req: Request, res Response) {
+    try {
+      await ClientRepository.deleteAll();
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+}
diff --git a/src/controllers/hotel.controller.ts b/src/controllers/hotel.controller.ts
index e69de29..8e718e0 100644
--- a/src/controllers/hotel.controller.ts
+++ b/src/controllers/hotel.controller.ts
@@ -0,0 +1,119 @@
+import { Request, Response } from "express";
+
+import Hotel from "../models/hotel.model";
+import HotelRepository from "../repositories/hotel.repository";
+
+export default class HotelController {
+  async create(req: Request, res Response) {
+    if (!req.body.name || !req.body.address) {
+      res.status(400).json({
+        message: "Content cannot be empty"
+      });
+    }
+
+    const hotel = {
+      name: req.body.name,
+      address: req.body.address,
+    };
+
+    try {
+      const hotel = await HotelRepository.create(hotel);
+      res.status(201).json(hotel);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!"
+      });
+    }
+  }
+
+  async findAll(req: Request, res Response) {
+    const name = req.query.name;
+    const address = req.query.address;
+
+    try {
+      const hotels = await HotelRepository.retrieveAll({name, address});
+      res.status(200).json(hotels);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async findOne(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      const hotel = await HotelRepository.retrieveById(req.body.id);
+      res.status(200).json(hotel);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async update(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    if (!req.body.name && !req.body.address) {
+      res.status(400).json({
+        message: "Content cannot be empty"
+      });
+    }
+
+    try {
+      const hotel = await hotelRepository.retrieveById(id);
+
+      if (req.body.name) {
+        hotel.name = req.body.name;
+      }
+      
+      if (req.body.address) {
+        hotel.name = req.body.address;
+      }
+
+      await hotelRepository.update(hotel);
+    } catch (err) {
+      res.status(404).json({
+        message: err || "Not found"
+      });
+    }
+  }
+
+  async delete(req: Request, res Response) {
+    if (!req.body.id) {
+      res.status(400).json({
+        message: "id cannot be empty"
+      });
+    }
+
+    try {
+      await HotelRepository.delete(req.body.id);
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+
+  async deleteAll(req: Request, res Response) {
+    try {
+      await HotelRepository.deleteAll();
+      res.status(204);
+    } catch (err) {
+      res.status(500).json({
+        message: err || "Internal Server Error!",
+      });
+    }
+  }
+}
diff --git a/src/repositories/booking.repository.ts b/src/repositories/booking.repository.ts
index 943def0..fc56392 100644
--- a/src/repositories/booking.repository.ts
+++ b/src/repositories/booking.repository.ts
@@ -2,7 +2,7 @@ import { Op } from "sequelize";
 import Booking from "../models/booking.model";
 
 interface IBookingRepository {
-  save(booking: Booking): Promise<Booking>;
+  create(booking: {clientId: number, hotelId: number}): Promise<Booking>;
   retrieveAll(searchParams: {name: string, address: string}): Promise<Booking[]>;
   retrieveById(bookingId: number): Promise<Booking | null>;
   update(booking: Booking): Promise<number>;
@@ -11,12 +11,9 @@ interface IBookingRepository {
 }
 
 class BookingRepository implements IBookingRepository {
-  async save(booking: Booking): Promise<Booking> {
+  async save(booking: {clientId: number, hotelId: number}): Promise<Booking> {
     try {
-      return await Booking.create({
-        hotelId: booking.hotel.id,
-        clientId: booking.client.id,
-      });
+      return await Booking.create(booking);
     } catch (err) {
       throw new Error("Failed to create Booking!");
     }
diff --git a/src/repositories/client.repository.ts b/src/repositories/client.repository.ts
index 2fa3bd5..705b03c 100644
--- a/src/repositories/client.repository.ts
+++ b/src/repositories/client.repository.ts
@@ -2,7 +2,7 @@ import { Op } from "sequelize";
 import Client from "../models/client.model";
 
 interface IClientRepository {
-  save(client: Client): Promise<Client>;
+  create(client: {name: string, address: string, phone: string}): Promise<Client>;
   retrieveAll(searchParams: {name: string, address: string}): Promise<Client[]>;
   retrieveById(clientId: number): Promise<Client | null>;
   update(client: Client): Promise<number>;
@@ -11,7 +11,7 @@ interface IClientRepository {
 }
 
 class ClientRepository implements IClientRepository {
-  async save(client: Client): Promise<Client> {
+  async create(client: {name: string, address: string, phone: string}): Promise<Client> {
     try {
       return await Client.create({
         name: client.name,
diff --git a/src/repositories/hotel.repository.ts b/src/repositories/hotel.repository.ts
index d2f857f..6552eb1 100644
--- a/src/repositories/hotel.repository.ts
+++ b/src/repositories/hotel.repository.ts
@@ -2,7 +2,7 @@ import { Op } from "sequelize";
 import Hotel from "../models/hotel.model";
 
 interface IHotelRepository {
-  save(hotel: Hotel): Promise<Hotel>;
+  create(hotel: {name: string, address: string}): Promise<Hotel>;
   retrieveAll(searchParams: {name: string, address: string}): Promise<Hotel[]>;
   retrieveById(hotelId: number): Promise<Hotel | null>;
   update(hotel: Hotel): Promise<number>;
@@ -11,7 +11,7 @@ interface IHotelRepository {
 }
 
 class HotelRepository implements IHotelRepository {
-  async save(hotel: Hotel): Promise<Hotel> {
+  async create(hotel: {name: string, address: string}): Promise<Hotel> {
     try {
       return await Hotel.create({
         name: hotel.name,