Feat : classification post list get api, 폴더별 post list get api 수정, 폴더 이름 list get api 에 정렬 적용

src/infrastructure/database/schema/AIClassification.schema.ts

@@ -28,6 +28,6 @@ export class AIClassification extends BaseDocument {
   deletedAt: Date;
 }
 
-export type PostAIClassificationDocument = HydratedDocument<AIClassification>;
-export const PostAIClassificationSchema =
+export type AIClassificationDocument = HydratedDocument<AIClassification>;
+export const AIClassificationSchema =
   SchemaFactory.createForClass(AIClassification);

src/infrastructure/database/schema/post.schema.ts

@@ -1,9 +1,10 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { HydratedDocument, Schema as MongooseSchema } from 'mongoose';
 import { AIClassification } from './AIClassification.schema';
+import { BaseDocument } from './base.schema';
 
 @Schema({ collection: 'posts', timestamps: true, versionKey: false })
-export class Post {
+export class Post extends BaseDocument {
   @Prop({ required: true, type: MongooseSchema.Types.ObjectId, ref: 'User' })
   userId!: MongooseSchema.Types.ObjectId;
 

src/modules/classification/classification.controller.ts

@@ -1,10 +1,20 @@
-import { Controller, Get, UseGuards, Param } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  UseGuards,
+  Param,
+  Query,
+  Delete,
+  Patch,
+} from '@nestjs/common';
 import { ClassificationService } from './classification.service';
-import { GetUser } from '@src/common';
+import { GetUser, PaginationQuery } from '@src/common';
 import {
   ClassificationControllerDocs,
   GetAIFolderNameListDocs,
   GetAIPostListDocs,
+  DeleteAIClassificationDocs,
+  PatchAIPostDocs,
 } from './docs';
 import { JwtGuard } from '../users/guards';
 import { AIFolderNameListResponse } from './response/ai-folder-list.dto';
@@ -16,26 +26,59 @@ import { AIPostListResponse } from './response/ai-post-list.dto';
 export class ClassificationController {
   constructor(private readonly classificationService: ClassificationService) {}
 
-  @Get('/suggestions') //TODO : 정렬
+  @Get('/folders')
   @GetAIFolderNameListDocs
-  async getSuggestedFolderNameList(@GetUser() userId: String) {
-    const folderNames =
-      await this.classificationService.getFolderNameList(userId);
+  async getSuggestedFolderNameList(@GetUser() userId: string) {
+    const folders = await this.classificationService.getFolderNameList(userId);
 
-    return new AIFolderNameListResponse(folderNames);
+    return new AIFolderNameListResponse(folders);
   }
-
-  @Get('/suggestions/:folderId')
+  @Get('/posts')
   @GetAIPostListDocs
   async getSuggestedPostList(
     @GetUser() userId: string,
-    @Param('folderId') folderId: string,
+    @Query() paingQuery: PaginationQuery,
   ) {
     const posts = await this.classificationService.getPostList(
+      userId,
+      paingQuery,
+    );
+
+    return new AIPostListResponse(posts);
+  }
+  @Get('/posts/:folderId')
+  @GetAIPostListDocs
+  async getSuggestedPostListInFolder(
+    @GetUser() userId: string,
+    @Param('folderId') folderId: string,
+    @Query() paingQuery: PaginationQuery,
+  ) {
+    const posts = await this.classificationService.getPostListInFolder(
       userId,
       folderId,
+      paingQuery,
     );
 
     return new AIPostListResponse(posts);
   }
+  @Patch('/posts')
+  @PatchAIPostDocs
+  async moveAllPost(
+    @GetUser() userId: string,
+    @Query('suggestionFolderId') suggestionFolderId: string,
+  ) {
+    await this.classificationService.moveAllPostTosuggestionFolder(
+      userId,
+      suggestionFolderId,
+    );
+  }
+
+  @Delete('/posts/:postId')
+  @DeleteAIClassificationDocs
+  async abortClassification(
+    @GetUser() userId: string,
+    @Query('postId') postId: string,
+  ) {
+    await this.classificationService.abortClassification(userId, postId);
+  }
 }

src/modules/classification/classification.module.ts

@@ -6,21 +6,23 @@ import {
   FolderSchema,
   Post,
   AIClassification,
-  PostAIClassificationSchema,
+  AIClassificationSchema,
   PostSchema,
 } from '@src/infrastructure/database/schema';
 
 import { ClassificationController } from './classification.controller';
+import { ClassficiationRepository } from './classification.repository';
+import { PostsRepository } from '../posts/posts.repository';
 
 @Module({
   imports: [
     MongooseModule.forFeature([
       { name: Folder.name, schema: FolderSchema },
-      { name: AIClassification.name, schema: PostAIClassificationSchema },
+      { name: AIClassification.name, schema: AIClassificationSchema },
       { name: Post.name, schema: PostSchema },
     ]),
   ],
   controllers: [ClassificationController],
-  providers: [ClassificationService],
+  providers: [ClassificationService, ClassficiationRepository, PostsRepository],
 })
 export class ClassificationModule {}

src/modules/classification/classification.repository.ts

@@ -0,0 +1,80 @@
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types, Schema } from 'mongoose';
+import { AIClassification, Folder } from '@src/infrastructure';
+import { ClassificationFolderWithCount } from './dto/classification.dto';
+
+@Injectable()
+export class ClassficiationRepository {
+  constructor(
+    @InjectModel(AIClassification.name)
+    private readonly aiClassificationModel: Model<AIClassification>,
+  ) {}
+
+  async findContainedFolderByUserId(
+    userId: Types.ObjectId,
+  ): Promise<ClassificationFolderWithCount[]> {
+    return await this.aiClassificationModel
+      .aggregate([
+        {
+          $match: {
+            deletedAt: null,
+          },
+        },
+        {
+          $lookup: {
+            from: 'folders',
+            localField: 'suggestedFolderId',
+            foreignField: '_id',
+            as: 'folder',
+          },
+        },
+        {
+          $unwind: '$folder',
+        },
+        {
+          $match: {
+            'folder.userId': userId,
+          },
+        },
+        {
+          $group: {
+            _id: '$suggestedFolderId',
+            folderName: { $first: '$folder.name' },
+            postCount: { $sum: 1 },
+            folderCreatedAt: { $first: '$folder.createdAt' },
+          },
+        },
+        {
+          $sort: {
+            postCount: -1,
+            folderCreatedAt: -1,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            folderId: { $toString: '$_id' },
+            folderName: 1,
+            postCount: 1,
+          },
+        },
+      ])
+      .exec();
+  }
+
+  async delete(id: string) {
+    await this.aiClassificationModel
+      .findByIdAndUpdate(id, { deletedAt: new Date() })
+      .exec();
+  }
+
+  async deleteBySuggestedFolderId(suggestedFolderId: string) {
+    await this.aiClassificationModel
+      .updateMany(
+        { suggestedFolderId: suggestedFolderId, deletedAt: null },
+        { $set: { deletedAt: new Date() } },
+      )
+      .exec();
+  }
+}

src/modules/classification/classification.service.ts

@@ -7,52 +7,96 @@ import {
 
 import { InjectModel } from '@nestjs/mongoose';
 import { Model, Types } from 'mongoose';
-import { AIFolderNameServiceDto } from './dto/getAIFolderNameLIst.dto';
-import { AIPostServiceDto } from './dto/getAIPostList.dto';
+import { ClassficiationRepository } from './classification.repository';
+import { PostsRepository } from '../posts/posts.repository';
+import {
+  ClassificationFolderWithCount,
+  PostListInClassificationFolder,
+} from './dto/classification.dto';
+import { PaginationQuery } from '@src/common';
+import { PostListInFolderResponse } from '../folders/responses';
 
 @Injectable()
 export class ClassificationService {
   constructor(
     @InjectModel(Folder.name) private folderModel: Model<Folder>,
-    @InjectModel(AIClassification.name)
-    private postAiClassificationModel: Model<AIClassification>,
     @InjectModel(Post.name) private postModel: Model<Post>,
+    private readonly classficationRepository: ClassficiationRepository,
+    private readonly postRepository: PostsRepository,
   ) {}
 
-  async getFolderNameList(userId: String): Promise<AIFolderNameServiceDto[]> {
-    const folders = await this.folderModel.find({ userId }).exec();
-    const folderIds = folders.map((folder) => folder._id);
+  async getFolderNameList(
+    userId: string,
+  ): Promise<ClassificationFolderWithCount[]> {
+    return await this.classficationRepository.findContainedFolderByUserId(
+      new Types.ObjectId(userId),
+    );
+  }
 
-    const classificationIds = await this.postAiClassificationModel
-      .distinct('suggestedFolderId')
-      .where('suggestedFolderId')
-      .in(folderIds)
-      .exec();
+  async getPostList(userId: string, paingQuery: PaginationQuery) {
+    const orderedFolderIdList = await this.getFolderOrder(userId);
 
-    const matchedFolders = await this.folderModel
-      .find({ _id: { $in: classificationIds } })
-      .exec();
+    const offset = (paingQuery.page - 1) * paingQuery.limit;
+    return await this.postRepository.findAndSortBySuggestedFolderIds(
+      new Types.ObjectId(userId),
+      orderedFolderIdList,
+      offset,
+      paingQuery.limit,
+    );
+  }
 
-    return matchedFolders.map((folder) => new AIFolderNameServiceDto(folder));
+  async getFolderOrder(userId: string) {
+    const orderedFolderList =
+      await this.classficationRepository.findContainedFolderByUserId(
+        new Types.ObjectId(userId),
+      );
+
+    return orderedFolderList.map(
+      (folder) => new Types.ObjectId(folder.folderId),
+    );
   }
 
-  async getPostList(
+  async getPostListInFolder(
     userId: string,
     folderId: string,
-  ): Promise<AIPostServiceDto[]> {
-    const posts = await this.postModel
-      .find({ userId: userId })
-      .populate<{
-        aiClassificationId: AIClassification;
-      }>({
-        path: 'aiClassificationId',
-        match: { deletedAt: null, suggestedFolderId: folderId },
-      })
-      .sort({ createdAt: -1 })
-      .exec();
-
-    return posts
-      .filter((post) => post.aiClassificationId)
-      .map((post) => new AIPostServiceDto(post, post.aiClassificationId));
+    paingQuery: PaginationQuery,
+  ): Promise<PostListInClassificationFolder[]> {
+    const offset = (paingQuery.page - 1) * paingQuery.limit;
+
+    return await this.postRepository.findBySuggestedFolderId(
+      userId,
+      new Types.ObjectId(folderId),
+      offset,
+      paingQuery.limit,
+    );
+  }
+  async moveAllPostTosuggestionFolder(
+    userId: string,
+    suggestedFolderId: string,
+  ) {
+    const postIdList =
+      await this.postRepository.findFolderIdsBySuggestedFolderId(
+        userId,
+        suggestedFolderId,
+      );
+
+    for (const post of postIdList) {
+      await this.postRepository.updateFolderId(
+        post._id.toString(),
+        suggestedFolderId,
+      );
+    }
+
+    await this.classficationRepository.deleteBySuggestedFolderId(
+      suggestedFolderId,
+    );
+  }
+
+  async abortClassification(userId: string, postId: string) {
+    const post = await this.postModel.findById(postId).exec();
+
+    await this.classficationRepository.delete(
+      post.aiClassificationId.toString(),
+    );
   }
 }

src/modules/classification/docs/controller.docs.ts

@@ -1,6 +1,7 @@
 import { applyDecorators } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
 
 export const ClassificationControllerDocs = applyDecorators(
   ApiTags('AI classification API'),
+  ApiBearerAuth(),
 );

src/modules/classification/docs/deleteAIClassification.docs.ts

@@ -0,0 +1,13 @@
+import { applyDecorators } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiResponse } from '@nestjs/swagger';
+import { AIFolderNameListResponse } from '../response/ai-folder-list.dto';
+
+export const DeleteAIClassificationDocs = applyDecorators(
+  ApiOperation({
+    summary: 'ai 분류 추천 리스트에서 삭제',
+    description:
+      'ai 분류 추천 리스트에서 삭제합니다. 나중에 읽을 폴더에 계속 위치됩니다.',
+  }),
+  ApiResponse({}),
+  ApiBearerAuth(),
+);

src/modules/classification/docs/getAIPostList.docs.ts

@@ -4,7 +4,7 @@ import { AIPostListResponse } from '../response/ai-post-list.dto';
 
 export const GetAIPostListDocs = applyDecorators(
   ApiOperation({
-    summary: '폴더 안에 들어있는 Post(링크) 리스트',
+    summary: 'Post(링크) 리스트',
     description: 'AI 분류 추천된 링크 리스트.',
   }),
   ApiResponse({

src/modules/classification/docs/index.ts

@@ -1,3 +1,5 @@
 export * from './controller.docs';
 export * from './getAIFolderNameList.docs';
 export * from './getAIPostList.docs';
+export * from './patchAIPost.docs';
+export * from './deleteAIClassification.docs';