Shows/schema: add genre reference

src/genres/genres.controller.ts

@@ -1,33 +1,105 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Param,
+  Delete,
+  BadRequestException,
+  Query,
+  InternalServerErrorException,
+  NotFoundException,
+} from '@nestjs/common';
 import { GenresService } from './genres.service';
 import { GenreDto } from './dto/genre.dto';
+import { PaginationDto } from 'src/pagination.dto';
 
 @Controller('genres')
 export class GenresController {
   constructor(private readonly genresService: GenresService) {}
 
   @Post()
-  create(@Body() dto: GenreDto) {
+  async create(@Body() dto: GenreDto) {
-    return this.genresService.create(dto);
+    try {
+      const newGenre = await this.genresService.create(dto);
+      return {
+        status: 'Ok',
+        message: 'Genre was created successfully',
+        newId: newGenre._id,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        status: 'Bad request',
+        message: error.message,
+      });
+    }
   }
 
   @Get()
-  findAll() {
+  async findAll(@Query() pagination: PaginationDto) {
-    return this.genresService.findAll();
+    try {
+      const { page, limit } = pagination;
+      const serviceResponse = await this.genresService.findAll(page, limit);
+      return {
+        status: 'Ok',
+        genres: serviceResponse.genres,
+        genreCount: serviceResponse.genreCount,
+      };
+    } catch (error) {
+      throw new InternalServerErrorException({
+        status: error.name,
+        message: error.message,
+      });
+    }
   }
 
-  @Get(':id')
+  @Get('/id/:id')
-  findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string) {
-    return this.genresService.findOne(+id);
+    try {
+      const genre = await this.genresService.findId(id);
+      if (genre) {
+        return { status: 'Ok', genre: genre };
+      } else {
+        throw new NotFoundException({
+          status: 'Error',
+          message: `Can't find genre with id ${id}`,
+        });
+      }
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw error;
+      }
+      throw new InternalServerErrorException({
+        status: error.name,
+        message: error.message,
+      });
+    }
   }
 
-  @Patch(':id')
+  @Delete('/id/:id')
-  update(@Param('id') id: string, @Body() dto: GenreDto) {
+  async remove(@Param('id') id: string) {
-    return this.genresService.update(+id, dto);
+    try {
-  }
+      const deletedMovie = await this.genresService.remove(id);
-
+      if (!deletedMovie) {
-  @Delete(':id')
+        throw new NotFoundException({
-  remove(@Param('id') id: string) {
+          status: 'Error',
-    return this.genresService.remove(+id);
+          message: `Can't find genre with id ${id}`,
+        });
+      } else {
+        return {
+          status: 'Ok',
+          message: 'Genre removed successfully',
+        };
+      }
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw error;
+      } else {
+        throw new InternalServerErrorException({
+          status: error.name,
+          message: error.message,
+        });
+      }
+    }
   }
 }

src/genres/genres.service.ts

@@ -1,25 +1,38 @@
 import { Injectable } from '@nestjs/common';
 import { GenreDto } from './dto/genre.dto';
+import { InjectModel } from '@nestjs/mongoose';
+import { Genre } from './entities/genre.entity';
+import { Model } from 'mongoose';
 
 @Injectable()
 export class GenresService {
-  create(dto: GenreDto) {
+  constructor(@InjectModel('Genre') private genreModel: Model<Genre>) {}
-    return 'This action adds a new genre';
+
+  async create(dto: GenreDto): Promise<any> {
+    const genre = new this.genreModel(dto);
+    return genre.save();
   }
 
-  findAll() {
+  async findAll(page: number, genresPerPage: number): Promise<any> {
-    return `This action returns all genres`;
+    let genres;
+    if (genresPerPage !== undefined) {
+      const skip = (page - 1) * genresPerPage;
+      genres = await this.genreModel.find().skip(skip).limit(genresPerPage);
+    } else {
+      genres = await this.genreModel.find();
+    }
+    const total = await this.genreModel.countDocuments();
+    return {
+      genres: genres,
+      genreCount: total,
+    };
   }
 
-  findOne(id: number) {
+  async findId(id: string): Promise<any> {
-    return `This action returns a #${id} genre`;
+    return this.genreModel.findById(id);
   }
 
-  update(id: number, dto: GenreDto) {
+  async remove(id: string): Promise<any> {
-    return `This action updates a #${id} genre`;
+    return this.genreModel.findByIdAndDelete(id);
-  }
-
-  remove(id: number) {
-    return `This action removes a #${id} genre`;
   }
 }

src/genres/schema/genres.schema.ts

@@ -2,5 +2,5 @@ import { Schema } from 'mongoose';
 
 export const GenreSchema = new Schema({
   name: { type: String, required: true },
-  showsIDs: [{ type: Schema.Types.ObjectId, ref: 'Show' }],
+  showIDs: [{ type: Schema.Types.ObjectId, ref: 'Show' }],
 });

src/shows/schema/show.schema.ts

@@ -6,6 +6,6 @@ export const ShowSchema = new Schema({
   seasons: { type: Number, required: true },
   episodes: { type: Number, required: true },
   description: { type: String, required: true },
-  genres: [{ type: String, required: true }],
+  genres: [{ type: Schema.Types.ObjectId, required: true, ref: 'Genre' }],
   images: [{ type: String, required: true }],
 });