Desafio Full Stack

back-end/.env.example

@@ -0,0 +1,7 @@
+#Database
+DATABASE_TYPE=
+DATABASE_HOST=
+DATABASE_PORT=
+DATABASE_NAME=
+DATABASE_USERNAME=
+DATABASE_PASSWORD=

back-end/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.env

back-end/jest.config.ts

@@ -0,0 +1,6 @@
+export default {
+  clearMocks: true,
+  coverageProvider: "v8",
+  preset: "ts-jest",
+  testMatch: ["**/**/*.spec.ts"],
+};

back-end/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "back-end",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "dev": "ts-node-dev --transpile-only --respawn --ignore-watch node_modules  src/server.ts",
+    "test": "jest"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.1",
+    "express": "^4.18.1",
+    "pg": "^8.7.3",
+    "reflect-metadata": "^0.1.13",
+    "typeorm": "^0.3.6"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/jest": "^27.5.1",
+    "jest": "^28.1.0",
+    "ts-jest": "^28.0.2",
+    "ts-node-dev": "^1.1.8",
+    "typescript": "^4.6.4"
+  }
+}

back-end/src/app.ts

@@ -0,0 +1,15 @@
+import express from "express";
+import cors from "cors";
+import dotenv from "dotenv";
+import "reflect-metadata";
+import "./database";
+import { routes } from "./routes";
+
+dotenv.config();
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+app.use(routes);
+
+export { app };

back-end/src/database/index.ts

@@ -0,0 +1,22 @@
+import { DataSource } from "typeorm"
+import 'dotenv/config';
+
+const AppDataSource = new DataSource({
+    type: process.env.DATABASE_TYPE as any,
+    host: process.env.DATABASE_HOST,
+    port: parseInt(process.env.DATABASE_PORT),
+    username: process.env.DATABASE_USERNAME,
+    password: process.env.DATABASE_PASSWORD,
+    database: process.env.DATABASE_NAME,
+    entities: [__dirname + '/../entities/*.ts']
+});
+
+AppDataSource.initialize()
+    .then(() => {
+        console.log("Data Source has been initialized!")
+    })
+    .catch((err) => {
+        console.error("Error during Data Source initialization", err)
+    });
+
+export { AppDataSource };

back-end/src/entities/Classroom.ts

@@ -0,0 +1,19 @@
+import { Entity, Column, PrimaryColumn } from "typeorm";
+import { v4 as uuid } from "uuid";
+
+@Entity('classrooms')
+export class Classroom {
+    @PrimaryColumn()
+    id: string;
+
+    @Column()
+    number: string;
+
+    constructor(props: Omit<Classroom, 'id'>, id?: string) {
+        Object.assign(this, props);
+
+        if (!this.id) {
+            this.id = uuid();
+        }
+    }
+}

back-end/src/entities/Course.ts

@@ -0,0 +1,61 @@
+import { Entity, Column, PrimaryColumn, ManyToMany, JoinTable } from "typeorm";
+import { Classroom } from "./Classroom";
+import { Teacher } from "./Teacher";
+import { v4 as uuid } from "uuid";
+
+@Entity('courses')
+export class Course {
+    @PrimaryColumn()
+    id: string;
+
+    @Column()
+    name: string;
+
+    @Column()
+    start_time: string
+
+    @Column()
+    end_time: string
+
+    @ManyToMany(() => Teacher, {
+        cascade: true,
+        onDelete: 'CASCADE'
+    })
+    @JoinTable({
+        name: 'courses_teachers',
+        joinColumn: {
+            name: "course_id",
+            referencedColumnName: "id"
+        },
+        inverseJoinColumn: {
+            name: "teacher_id",
+            referencedColumnName: "id"
+        }
+    })
+    teachers: Teacher[]
+
+    @ManyToMany(() => Classroom, {
+        cascade: true,
+        onDelete: 'CASCADE'
+    })
+    @JoinTable({
+        name: 'courses_classrooms',
+        joinColumn: {
+            name: "course_id",
+            referencedColumnName: "id"
+        },
+        inverseJoinColumn: {
+            name: "classroom_id",
+            referencedColumnName: "id"
+        }
+    })
+    classrooms: Classroom[]
+
+    constructor(props: Omit<Course, 'id'>, id?: string) {
+        Object.assign(this, props);
+
+        if (!this.id) {
+            this.id = uuid();
+        }
+    }
+}

back-end/src/entities/Teacher.ts

@@ -0,0 +1,19 @@
+import { Entity, Column, PrimaryColumn } from "typeorm";
+import { v4 as uuid } from "uuid";
+
+@Entity('teachers')
+export class Teacher {
+    @PrimaryColumn()
+    id: string;
+
+    @Column()
+    name: string;
+
+    constructor(props: Omit<Teacher, 'id'>, id?: string) {
+        Object.assign(this, props);
+
+        if (!this.id) {
+            this.id = uuid();
+        }
+    }
+}

back-end/src/entities/User.ts

@@ -0,0 +1,22 @@
+import { Entity, Column, PrimaryColumn } from "typeorm";
+import { v4 as uuid } from "uuid";
+
+@Entity('users')
+export class User {
+    @PrimaryColumn()
+    id: string;
+
+    @Column()
+    email: string;
+
+    @Column()
+    password: string;
+
+    constructor(props: Omit<User, 'id'>, id?: string) {
+        Object.assign(this, props);
+
+        if (!this.id) {
+            this.id = uuid();
+        }
+    }
+}

back-end/src/modules/createCourse/CreateCourseController.ts

@@ -0,0 +1,19 @@
+import { Request, Response } from 'express';
+import { CreateCourseService } from './CreateCourseService';
+import { ICreateCourseDTO } from './CreateCourseDTO';
+
+export class CreateCourseController {
+    constructor(private createCourseService: CreateCourseService) {}
+
+    async handle (request: Request, response: Response) : Promise<Response> {
+        const data: ICreateCourseDTO = request.body;
+
+        try {
+            const course = await this.createCourseService.execute(data);
+
+            return response.status(201).json(course);
+        } catch (err) {
+            return response.status(400).json({ message: err.message || 'Unexpected error.'})
+        }
+    }
+}

back-end/src/modules/createCourse/CreateCourseDTO.ts

@@ -0,0 +1,7 @@
+export interface ICreateCourseDTO {
+    name: string;
+    start_time: string;
+    end_time: string;
+    teacher_ids: string[];
+    classroom_ids: string[];
+}

back-end/src/modules/createCourse/CreateCourseFactory.ts

@@ -0,0 +1,11 @@
+import { PostgresCoursesRepository } from "../../repositories/implementations/PostgresCoursesRepository";
+import { CreateCourseService } from "./CreateCourseService";
+import { CreateCourseController } from "./CreateCourseController";
+
+const postgresCoursesRepository = new PostgresCoursesRepository();
+
+const createCourseService = new CreateCourseService(postgresCoursesRepository);
+
+const createCourseController = new CreateCourseController(createCourseService);
+
+export { createCourseService, createCourseController };

back-end/src/modules/createCourse/CreateCourseService.spec.ts

@@ -0,0 +1,49 @@
+import { CreateCourseService } from "./CreateCourseService";
+import { CoursesRepositoryStub } from "../../repositories/stub/CoursesRepositoryStub";
+
+
+describe("Create course", () => {
+    let sut: CreateCourseService;
+
+    beforeAll(() => {
+        sut = new CreateCourseService(new CoursesRepositoryStub());
+    });
+
+    it("should create a new course", async () => {
+        const courseData = {
+            name: "test course",
+            start_time: "10:00:00",
+            end_time: "12:00:00",
+            teacher_ids: ["test_id"],
+            classroom_ids: ["test_id"]
+        }
+
+        const course = await sut.execute(courseData);
+
+        expect(course).toHaveProperty('id');
+    });
+
+    it("should not create a course without at least one teacher", async () => {
+        const courseData = {
+            name: "test course",
+            start_time: "10:00:00",
+            end_time: "12:00:00",
+            teacher_ids: [],
+            classroom_ids: ["test_id"]
+        }
+
+        await expect(sut.execute(courseData)).rejects.toEqual(new Error('A course must have at least one teacher'));
+    });
+
+    it("should not create a course without at least one classroom", async () => {
+        const courseData = {
+            name: "test course",
+            start_time: "10:00:00",
+            end_time: "12:00:00",
+            teacher_ids: ["test_id"],
+            classroom_ids: []
+        }
+
+        await expect(sut.execute(courseData)).rejects.toEqual(new Error('A course must have at least one classroom'));
+    });
+});

back-end/src/modules/createCourse/CreateCourseService.ts

@@ -0,0 +1,18 @@
+import { ICoursesRepository } from "../../repositories/ICoursesRepository";
+import { ICreateCourseDTO } from "./CreateCourseDTO";
+
+export class CreateCourseService {
+    constructor(private coursesRepository: ICoursesRepository) {}
+
+    async execute(data: ICreateCourseDTO) {
+        if (!data.teacher_ids || data.teacher_ids.length === 0) {
+            throw new Error('A course must have at least one teacher');
+        }
+
+        if (!data.classroom_ids || data.classroom_ids.length === 0) {
+            throw new Error('A course must have at least one classroom');
+        }
+
+        return await this.coursesRepository.save(data);
+    }
+}

back-end/src/modules/deleteCourse/DeleteCourseController.ts

@@ -0,0 +1,18 @@
+import { Request, Response } from "express";
+import { DeleteCourseService } from "./DeleteCourseService";
+
+export class DeleteCourseController {
+    constructor(private deleteCourseService: DeleteCourseService) {}
+
+    async handle (request: Request, response: Response) {
+        try {
+            const { id } = request.params;
+
+            await this.deleteCourseService.execute(id);
+
+            return response.status(200).json({ message: `Course ${id} deleted!`});
+        } catch (err) {
+            return response.status(400).json({ message: err.message || 'Unexpected error.'})
+        }
+    }
+}

back-end/src/modules/deleteCourse/DeleteCourseFactory.ts

@@ -0,0 +1,11 @@
+import { PostgresCoursesRepository } from "../../repositories/implementations/PostgresCoursesRepository";
+import { DeleteCourseService } from "./DeleteCourseService";
+import { DeleteCourseController } from "./DeleteCourseController";
+
+const postgresCoursesRepository = new PostgresCoursesRepository();
+
+const deleteCourseService = new DeleteCourseService(postgresCoursesRepository);
+
+const deleteCourseController = new DeleteCourseController(deleteCourseService);
+
+export { deleteCourseService, deleteCourseController};

back-end/src/modules/deleteCourse/DeleteCourseService.ts

@@ -0,0 +1,9 @@
+import { ICoursesRepository } from "../../repositories/ICoursesRepository";
+
+export class DeleteCourseService {
+    constructor(private coursesRepository: ICoursesRepository) {}
+
+    async execute (id: string): Promise<void> {
+        await this.coursesRepository.delete(id);
+    }
+}

back-end/src/modules/editCourse/EditCourseController.ts

@@ -0,0 +1,20 @@
+import { Request, Response } from "express";
+import { EditCourseService } from "./EditCourseService";
+import { IEditCourseDTO } from "./EditCourseDTO";
+
+export class EditCourseController {
+    constructor(private editCourseService: EditCourseService) {}
+
+    async handle (request: Request, response: Response) {
+        const { id } = request.params;
+        const data: IEditCourseDTO = request.body;
+
+        try {
+            const course = await this.editCourseService.execute(id, data);
+
+            return response.status(200).json(course);
+        } catch (err) {
+            return response.status(400).json({ message: err.message || 'Unexpected error.'})
+        }
+    }
+}