✨ Add episode progression DTO and payload; implement progression management routes

Author: Xen0Xys

src/modules/misc/misc.service.ts

@@ -3,7 +3,7 @@ import axios, {AxiosInstance} from "axios";
 import {Injectable} from "@nestjs/common";
 import {createHash, randomBytes} from "crypto";
 import * as JSZip from "jszip";
-import sharp from "sharp";
+import * as sharp from "sharp";
 import * as fs from "fs";
 
 @Injectable()

src/modules/users/models/dto/episode-progression.dto.ts

@@ -0,0 +1,7 @@
+import {IsInt, IsNotEmpty} from "class-validator";
+
+export class EpisodeProgressionDto{
+    @IsInt()
+    @IsNotEmpty()
+    progression: number;
+}

src/modules/users/models/payloads/episode-progression.payload.ts

@@ -0,0 +1,4 @@
+export class EpisodeProgressionPayload{
+    episodeId: number;
+    progression: number;
+}

src/modules/users/users.controller.ts

@@ -1,11 +1,13 @@
-import {Body, Controller, Get, Param, Post, UseGuards} from "@nestjs/common";
+import {Body, Controller, Delete, Get, HttpCode, Param, Post, UseGuards} from "@nestjs/common";
 import {UserEntity} from "./models/entities/user.entity";
 import {LoginPayload} from "./models/payloads/login.payload";
 import {User} from "./decorators/user.decorator";
 import {LoginDto} from "./models/dto/login.dto";
 import {ApiBearerAuth} from "@nestjs/swagger";
 import {UsersService} from "./users.service";
 import {AuthGuard} from "@nestjs/passport";
+import {HttpStatusCode} from "axios";
+import {EpisodeProgressionDto} from "./models/dto/episode-progression.dto";
 
 @Controller("user")
 export class UsersController{
@@ -54,10 +56,32 @@ export class UsersController{
         return await this.usersService.getEpisodeProgression(user, episodeId);
     }
 
-    @Post("progression/:episode_id")
+    @Post("progression/episode/:episode_id")
     @UseGuards(AuthGuard("jwt"))
     @ApiBearerAuth()
-    async setEpisodeProgression(@User() user: UserEntity, @Param("episode_id") episodeId: number, @Body("progression") progression: number): Promise<void>{
-        await this.usersService.setEpisodeProgression(user, episodeId, progression);
+    async setEpisodeProgression(@User() user: UserEntity, @Param("episode_id") episodeId: number, @Body() progression: EpisodeProgressionDto): Promise<void>{
+        await this.usersService.setEpisodeProgression(user, episodeId, progression.progression);
+    }
+
+    @Delete("progression")
+    @HttpCode(HttpStatusCode.NoContent)
+    @UseGuards(AuthGuard("jwt"))
+    @ApiBearerAuth()
+    async deleteAllProgressions(@User() user: UserEntity): Promise<void>{
+        await this.usersService.deleteAllProgressions(user);
+    }
+
+    @Delete("progression/webtoon/:webtoon_id")
+    @UseGuards(AuthGuard("jwt"))
+    @ApiBearerAuth()
+    async deleteWebtoonProgression(@User() user: UserEntity, @Param("webtoon_id") webtoonId: number): Promise<void>{
+        await this.usersService.deleteWebtoonProgression(user, webtoonId);
+    }
+
+    @Delete("progression/episode/:episode_id")
+    @UseGuards(AuthGuard("jwt"))
+    @ApiBearerAuth()
+    async deleteEpisodeProgression(@User() user: UserEntity, @Param("episode_id") episodeId: number): Promise<void>{
+        await this.usersService.deleteEpisodeProgression(user, episodeId);
     }
 }

src/modules/users/users.service.ts

@@ -6,6 +6,7 @@ import {PrismaService} from "../misc/prisma.service";
 import {MiscService} from "../misc/misc.service";
 import {EpisodeProgressions, Images, Users} from "@prisma/client";
 import {JwtService} from "@nestjs/jwt";
+import {EpisodeProgressionPayload} from "./models/payloads/episode-progression.payload";
 
 @Injectable()
 export class UsersService{
@@ -109,11 +110,24 @@ export class UsersService{
         };
     }
 
-    async getWebtoonProgression(user: UserEntity, webtoonId: number){
-        // TODO
+    async getWebtoonProgression(user: UserEntity, webtoonId: number): Promise<EpisodeProgressionPayload[]>{
+        const episodeProgressions: EpisodeProgressions[] = await this.prismaService.episodeProgressions.findMany({
+            where: {
+                user_id: user.id,
+                episode: {
+                    webtoon_id: webtoonId,
+                },
+            },
+        });
+        if(!episodeProgressions.length)
+            return [];
+        return episodeProgressions.map((episodeProgression: EpisodeProgressions): EpisodeProgressionPayload => ({
+            episodeId: episodeProgression.episode_id,
+            progression: episodeProgression.progression,
+        }));
     }
 
-    async getEpisodeProgression(user: UserEntity, episodeId: number): Promise<number>{
+    async getEpisodeProgression(user: UserEntity, episodeId: number): Promise<EpisodeProgressionPayload>{
         const episodeProgression: EpisodeProgressions = await this.prismaService.episodeProgressions.findUnique({
             where: {
                 user_id_episode_id: {
@@ -124,34 +138,68 @@ export class UsersService{
         });
         if(!episodeProgression)
             throw new NotFoundException("Episode progression not found");
-        return episodeProgression.progression;
+        return {
+            episodeId,
+            progression: episodeProgression.progression,
+        } as EpisodeProgressionPayload;
     }
 
     async setEpisodeProgression(user: UserEntity, episodeId: number, progression: number){
-        const episodeProgression: EpisodeProgressions = await this.prismaService.episodeProgressions.findUnique({
+        const episodeProgression: EpisodeProgressions | undefined = await this.prismaService.episodeProgressions.findUnique({
             where: {
                 user_id_episode_id: {
                     user_id: user.id,
                     episode_id: episodeId,
                 },
             },
         });
-        if(!episodeProgression)
-            throw new NotFoundException("Episode progression not found");
         if(progression < 0)
             throw new BadRequestException("Invalid progression");
-        if(progression < episodeProgression.progression)
+        if(progression < (episodeProgression?.progression || 0))
             throw new BadRequestException("New progression must be greater than existing one");
-        await this.prismaService.episodeProgressions.update({
+        await this.prismaService.episodeProgressions.upsert({
             where: {
                 user_id_episode_id: {
-                    user_id: episodeProgression.user_id,
-                    episode_id: episodeProgression.episode_id,
+                    user_id: user.id,
+                    episode_id: episodeId,
                 },
             },
-            data: {
+            create: {
+                user_id: user.id,
+                episode_id: episodeId,
                 progression,
             },
+            update: {
+                progression,
+            },
+        });
+    }
+
+    async deleteAllProgressions(user: UserEntity){
+        await this.prismaService.episodeProgressions.deleteMany({
+            where: {
+                user_id: user.id,
+            },
+        });
+    }
+
+    async deleteWebtoonProgression(user: UserEntity, webtoonId: number){
+        await this.prismaService.episodeProgressions.deleteMany({
+            where: {
+                user_id: user.id,
+                episode: {
+                    webtoon_id: webtoonId,
+                },
+            },
+        });
+    }
+
+    async deleteEpisodeProgression(user: UserEntity, episodeId: number){
+        await this.prismaService.episodeProgressions.deleteMany({
+            where: {
+                user_id: user.id,
+                episode_id: episodeId,
+            },
         });
     }
 }