Add repositories

src/repositories/booking.repository.ts

@@ -0,0 +1,68 @@
+import { Op } from "sequelize";
+import Booking from "../models/booking.model";
+
+interface IBookingRepository {
+  save(booking: Booking): Promise<Booking>;
+  retrieveAll(searchParams: {name: string, address: string}): Promise<Booking[]>;
+  retrieveById(bookingId: number): Promise<Booking | null>;
+  update(booking: Booking): Promise<number>;
+  delete(bookingId: number): Promise<number>;
+  deleteAll(): Promise<number>;
+}
+
+class BookingRepository implements IBookingRepository {
+  async save(booking: Booking): Promise<Booking> {
+    try {
+      return await Booking.create({
+        hotelId: booking.hotel.id,
+        clientId: booking.client.id,
+      });
+    } catch (err) {
+      throw new Error("Failed to create Booking!");
+    }
+  }
+
+  async retrieveAll(): Promise<Booking[]> {
+    try {
+      return await Booking.findAll();
+    } catch (error) {
+      throw new Error("Failed to retrieve Bookings!");
+    }
+  }
+
+  async retrieveById(bookingId: number): Promise<Booking | null> {
+    try {
+      return await Booking.findByPk(bookingId);
+    } catch (error) {
+      throw new Error("Failed to retrieve Booking!");
+    }
+  }
+
+  async update(booking: Booking): Promise<number> {
+    throw new Error("Failed to update Booking!");
+  }
+
+  async delete(bookingId: number): Promise<number> { 
+    try {
+      const affectedRows = await Booking.destroy({ where: { id: bookingId } });
+
+      return affectedRows;
+    } catch (error) {
+      throw new Error("Failed to delete Booking!");
+    }
+  }
+
+  async deleteAll(): Promise<number> {
+    try {
+      return Booking.destroy({
+        where: {},
+        truncate: false
+      });
+    } catch (error) {
+      throw new Error("Failed to delete Bookings!");
+    }
+  }
+}
+
+export default new BookingRepository();
+

src/repositories/client.repository.ts

@@ -0,0 +1,93 @@
+import { Op } from "sequelize";
+import Client from "../models/client.model";
+
+interface IClientRepository {
+  save(client: Client): Promise<Client>;
+  retrieveAll(searchParams: {name: string, address: string}): Promise<Client[]>;
+  retrieveById(clientId: number): Promise<Client | null>;
+  update(client: Client): Promise<number>;
+  delete(clientId: number): Promise<number>;
+  deleteAll(): Promise<number>;
+}
+
+class ClientRepository implements IClientRepository {
+  async save(client: Client): Promise<Client> {
+    try {
+      return await Client.create({
+        name: client.name,
+        address: client.address,
+        phone: client.phone,
+      });
+    } catch (err) {
+      throw new Error("Failed to create Client!");
+    }
+  }
+
+  async retrieveAll(searchParams: {name?: string, address?: string, phone?: string): Promise<Client[]> {
+    try {
+      let condition: SearchCondition = {};
+
+      if (searchParams?.name) {
+        condition.name = { [Op.like]: `%${searchParams.name}%` };
+      }
+
+      if (searchParams?.address) {
+        condition.address = { [Op.like]: `%${searchParams.address}%` };
+      }
+
+      if (searchParams?.phone) {
+        condition.phone = { [Op.like]: `%${searchParams.phone}%` };
+      }
+
+      return await Client.findAll({ where: condition });
+    } catch (error) {
+      throw new Error("Failed to retrieve Clients!");
+    }
+  }
+
+  async retrieveById(clientId: number): Promise<Client | null> {
+    try {
+      return await Client.findByPk(clientId);
+    } catch (error) {
+      throw new Error("Failed to retrieve Client!");
+    }
+  }
+
+  async update(client: Client): Promise<number> {
+    const { id, name, address, phone } = client;
+
+    try {
+      const affectedRows = await Client.update(
+        { name, address, phone},
+        { where: { id: id } }
+      );
+
+      return affectedRows[0];
+    } catch (error) {
+      throw new Error("Failed to update Client!");
+    }
+  }
+
+  async delete(clientId: number): Promise<number> { 
+    try {
+      const affectedRows = await Client.destroy({ where: { id: clientId } });
+
+      return affectedRows;
+    } catch (error) {
+      throw new Error("Failed to delete Client!");
+    }
+  }
+
+  async deleteAll(): Promise<number> {
+    try {
+      return Client.destroy({
+        where: {},
+        truncate: false
+      });
+    } catch (error) {
+      throw new Error("Failed to delete Clients!");
+    }
+  }
+}
+
+export default new ClientRepository();

src/repositories/hotel.repository.ts

@@ -0,0 +1,87 @@
+import { Op } from "sequelize";
+import Hotel from "../models/hotel.model";
+
+interface IHotelRepository {
+  save(hotel: Hotel): Promise<Hotel>;
+  retrieveAll(searchParams: {name: string, address: string}): Promise<Hotel[]>;
+  retrieveById(hotelId: number): Promise<Hotel | null>;
+  update(hotel: Hotel): Promise<number>;
+  delete(hotelId: number): Promise<number>;
+  deleteAll(): Promise<number>;
+}
+
+class HotelRepository implements IHotelRepository {
+  async save(hotel: Hotel): Promise<Hotel> {
+    try {
+      return await Hotel.create({
+        name: hotel.name,
+        address: hotel.address,
+      });
+    } catch (err) {
+      throw new Error("Failed to create Hotel!");
+    }
+  }
+
+  async retrieveAll(searchParams: {name?: string, address?: string): Promise<Hotel[]> {
+    try {
+      let condition: SearchCondition = {};
+
+      if (searchParams?.name) {
+        condition.name = { [Op.like]: `%${searchParams.name}%` };
+      }
+
+      if (searchParams?.address) {
+        condition.address = { [Op.like]: `%${searchParams.address}%` };
+      }
+      return await Hotel.findAll({ where: condition });
+    } catch (error) {
+      throw new Error("Failed to retrieve Hotels!");
+    }
+  }
+
+  async retrieveById(hotelId: number): Promise<Hotel | null> {
+    try {
+      return await Hotel.findByPk(hotelId);
+    } catch (error) {
+      throw new Error("Failed to retrieve Hotel!");
+    }
+  }
+
+  async update(hotel: Hotel): Promise<number> {
+    const { id, name, address } = hotel;
+
+    try {
+      const affectedRows = await Hotel.update(
+        { name, address },
+        { where: { id: id } }
+      );
+
+      return affectedRows[0];
+    } catch (error) {
+      throw new Error("Failed to update Hotel!");
+    }
+  }
+
+  async delete(hotelId: number): Promise<number> { 
+    try {
+      const affectedRows = await Hotel.destroy({ where: { id: hotelId } });
+
+      return affectedRows;
+    } catch (error) {
+      throw new Error("Failed to delete Hotel!");
+    }
+  }
+
+  async deleteAll(): Promise<number> {
+    try {
+      return Hotel.destroy({
+        where: {},
+        truncate: false
+      });
+    } catch (error) {
+      throw new Error("Failed to delete Hotels!");
+    }
+  }
+}
+
+export default new HotelRepository();