alex
/
prueba_intricom
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: alex:4d1da02b5f25d0dc0685a77fb338348f80093c92
Branches Tags
alex:main
..
compare: alex:0140d93b9ab8faaefdbd707616d18ff0d84f25ed
Branches Tags
alex:main

No commits in common. "4d1da02b5f25d0dc0685a77fb338348f80093c92" and "0140d93b9ab8faaefdbd707616d18ff0d84f25ed" have entirely different histories.
4d1da02b5f ... 0140d93b9a

13 changed files with 36 additions and 688 deletions
Show Stats Expand all files Collapse all files

90
src/controllers/booking.controller.ts
View File

@ -1,90 +0,0 @@
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!",
});
}
}
}

125
src/controllers/client.controller.ts
View File

@ -1,125 +0,0 @@
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!",
});
}
}
}

119
src/controllers/hotel.controller.ts
View File

@ -1,119 +0,0 @@
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!",
});
}
}
}

21
src/models/booking.model.ts
View File

@ -9,6 +9,7 @@ import Client from "./client.model.ts";
export default class Booking extends Model { export default class Booking extends Model {
@Unique @Unique
@Column({ @Column({
type: DataType.INTEGER,
primaryKey: true, primaryKey: true,
autoIncrement: true, autoIncrement: true,
field: "id" field: "id"
@ -17,6 +18,7 @@ export default class Booking extends Model {
@ForeignKey(() => Hotel) @ForeignKey(() => Hotel)
@Column({ @Column({
type: DataType.INTEGER,
field: "HotelId" field: "HotelId"
}) })
hotelId: number; hotelId: number;
@ -24,11 +26,28 @@ export default class Booking extends Model {
@BelongsTo(() => Hotel) @BelongsTo(() => Hotel)
hotel: Hotel; hotel: Hotel;
@CreatedAt @Column({
type: DataType.STRING(255),
field: "Name"
})
name?: string;
@Column({
type: DataType.STRING(255),
field: "Address"
})
address?: string;
@Column({
type: DataType.DATE,
field: "CreatedDate"
defaultValue: DataType.NOW
})
createdDate: Date; createdDate: Date;
@ForeignKey(() => Client) @ForeignKey(() => Client)
@Column({ @Column({
type: DataType.INTEGER,
field: "clientId" field: "clientId"
}) })
clientId: number; clientId: number;

10
src/models/client.model.ts
View File

@ -9,6 +9,7 @@ import Booking from "./booking.model.ts";
export default class Client extends Model { export default class Client extends Model {
@Unique @Unique
@Column({ @Column({
type: DataType.INTEGER,
primaryKey: true, primaryKey: true,
autoIncrement: true, autoIncrement: true,
field: "id" field: "id"
@ -16,21 +17,28 @@ export default class Client extends Model {
id: number; id: number;
@Column({ @Column({
type: DataType.STRING(255),
field: "Name" field: "Name"
}) })
name: string; name: string;
@Column({ @Column({
type: DataType.STRING(255),
field: "Address" field: "Address"
}) })
address: string; address: string;
@Column({ @Column({
type: DataType.STRING(255),
field: "Phone" field: "Phone"
}) })
phone: string; phone: string;
@CreatedAt @Column({
type: DataType.DATE,
field: "CreatedDate"
defaultValue: DataType.NOW
})
createdDate: Date; createdDate: Date;
@HasMany(() => Booking) @HasMany(() => Booking)

8
src/models/hotel.model.ts
View File

@ -17,16 +17,22 @@ export default class Hotel extends Model {
id: number; id: number;
@Column({ @Column({
type: DataType.STRING(255),
field: "Name" field: "Name"
}) })
name: string; name: string;
@Column({ @Column({
type: DataType.STRING(255),
field: "Address" field: "Address"
}) })
address: string; address: string;
@CreatedAt @Column({
type: DataType.DATE,
field: "CreatedDate"
defaultValue: DataType.NOW
})
createdDate: Date; createdDate: Date;
@HasMany(() => Booking) @HasMany(() => Booking)

65
src/repositories/booking.repository.ts
View File

@ -1,65 +0,0 @@
import { Op } from "sequelize";
import Booking from "../models/booking.model";
interface IBookingRepository {
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>;
delete(bookingId: number): Promise<number>;
deleteAll(): Promise<number>;
}
class BookingRepository implements IBookingRepository {
async save(booking: {clientId: number, hotelId: number}): Promise<Booking> {
try {
return await Booking.create(booking);
} 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();

93
src/repositories/client.repository.ts
View File

@ -1,93 +0,0 @@
import { Op } from "sequelize";
import Client from "../models/client.model";
interface IClientRepository {
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>;
delete(clientId: number): Promise<number>;
deleteAll(): Promise<number>;
}
class ClientRepository implements IClientRepository {
async create(client: {name: string, address: string, phone: string}): 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();

87
src/repositories/hotel.repository.ts
View File

@ -1,87 +0,0 @@
import { Op } from "sequelize";
import Hotel from "../models/hotel.model";
interface IHotelRepository {
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>;
delete(hotelId: number): Promise<number>;
deleteAll(): Promise<number>;
}
class HotelRepository implements IHotelRepository {
async create(hotel: {name: string, address: string}): 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();

31
src/routes/booking.routes.js
View File

@ -1,31 +0,0 @@
import { Router } from "express";
import BookingController from "../controllers/booking.controller";
class BookingRoutes {
router = Router();
controller = new BookingController();
constructor() {
this.intializeRoutes();
}
intializeRoutes() {
// Create a new Booking
this.router.post("/", this.controller.create);
// Retrieve all Bookings
this.router.get("/", this.controller.findAll);
// Retrieve a single Booking with id
this.router.get("/:id", this.controller.findOne);
// Update a Booking with id
this.router.put("/:id", this.controller.update);
// Delete a Booking with id
this.router.delete("/:id", this.controller.delete);
}
}
export default new BookingRoutes().router;

31
src/routes/client.routes.js
View File

@ -1,31 +0,0 @@
import { Router } from "express";
import ClientController from "../controllers/client.controller";
class ClientRoutes {
router = Router();
controller = new ClientController();
constructor() {
this.intializeRoutes();
}
intializeRoutes() {
// Create a new Client
this.router.post("/", this.controller.create);
// Retrieve all Clients
this.router.get("/", this.controller.findAll);
// Retrieve a single Client with id
this.router.get("/:id", this.controller.findOne);
// Update a Client with id
this.router.put("/:id", this.controller.update);
// Delete a Client with id
this.router.delete("/:id", this.controller.delete);
}
}
export default new ClientRoutes().router;

31
src/routes/hotel.routes.js
View File

@ -1,31 +0,0 @@
import { Router } from "express";
import HotelController from "../controllers/hotel.controller";
class HotelRoutes {
router = Router();
controller = new HotelController();
constructor() {
this.intializeRoutes();
}
intializeRoutes() {
// Create a new Hotel
this.router.post("/", this.controller.create);
// Retrieve all Hotels
this.router.get("/", this.controller.findAll);
// Retrieve a single Hotel with id
this.router.get("/:id", this.controller.findOne);
// Update a Hotel with id
this.router.put("/:id", this.controller.update);
// Delete a Hotel with id
this.router.delete("/:id", this.controller.delete);
}
}
export default new HotelRoutes().router;

13
src/routes/index.ts
View File

@ -1,13 +0,0 @@
import { Application } from "express";
import hotelRoutes from "./hotel.routes";
import clientRoutes from "./client.routes";
import bookingRoutes from "./booking.routes";
export default class Routes {
constructor(app: Application) {
app.use("/api/hotels", hotelRoutes);
app.use("/api/client", clientRoutes);
app.use("/api/booking", bookingRoutes);
}
}