Merge pull request #87 from umc-commit/feat/86-info-artist

Author: weejee12

src/commission/commission.routes.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import { 
     getCommissionDetail,
+    getCommissionArtistInfo,
     getCommissionForm,
     uploadRequestImage,
     submitCommissionRequest
@@ -12,6 +13,9 @@ const router = Router();
 // 커미션 게시글 상세글 조회 API
 router.get('/:commissionId', authenticate, getCommissionDetail);
 
+// 커미션 게시글 작가 정보 조회 API
+router.get('/:commissionId/artist', authenticate, getCommissionArtistInfo);
+
 // 커미션 신청폼 조회 API
 router.get('/:commissionId/forms', authenticate, getCommissionForm);
 

src/commission/controller/commission.controller.js

@@ -1,7 +1,9 @@
+// /src/commission/controller/commission.controller.js
 import { StatusCodes } from "http-status-codes";
 import { CommissionService } from '../service/commission.service.js';
 import 
 { GetCommissionDetailDto,
+  GetCommissionArtistInfoDto,
   GetCommissionFormDto,
   SubmitCommissionRequestDto
  } from "../dto/commission.dto.js";
@@ -24,6 +26,25 @@ export const getCommissionDetail = async (req, res, next) => {
  }
 };
 
+// 커미션 게시글 작가 정보 조회
+export const getCommissionArtistInfo = async (req, res, next) => {
+  try {
+    const userId = req.user.userId ? BigInt(req.user.userId) : null;
+    const dto = new GetCommissionArtistInfoDto({
+      commissionId: BigInt(req.params.commissionId),
+      page: req.query.page,
+      limit: req.query.limit
+    });
+
+    const result = await CommissionService.getCommissionArtistInfo(userId, dto);
+    const responseData = parseWithBigInt(stringifyWithBigInt(result));
+
+    res.status(StatusCodes.OK).success(responseData);
+  } catch (err) {
+    next(err);
+  }
+};
+
 // 커미션 신청폼 조회
 export const getCommissionForm = async (req, res, next) => {
   try {

src/commission/dto/commission.dto.js

@@ -5,6 +5,15 @@ export class GetCommissionDetailDto {
   }
 }
 
+// 커미션 게시글 작가 정보 조회 dto
+export class GetCommissionArtistInfoDto {
+  constructor({ commissionId, page = 1, limit = 10 }) {
+    this.commissionId = commissionId;
+    this.page = parseInt(page);
+    this.limit = parseInt(limit);
+  }
+}
+
 // 커미션 신청폼 조회 dto
 export class GetCommissionFormDto {
   constructor({ commissionId }) {

src/commission/repository/commission.repository.js

@@ -1,3 +1,4 @@
+// /src/commission/repository/commission.repository.js
 import { prisma } from "../../db.config.js"
 
 export const CommissionRepository = {
@@ -143,5 +144,136 @@ export const CommissionRepository = {
         commissionId: BigInt(commissionId)
       }
     });
+  },
+
+  /**
+   * 커미션 ID로 작가 정보 조회 (팔로우 여부 포함)
+   */
+  async findArtistInfoByCommissionId(commissionId, userId) {
+    return await prisma.commission.findUnique({
+      where: {
+        id: BigInt(commissionId)
+      },
+      include: {
+        artist: {
+          include: {
+            follows: userId ? {
+              where: { userId: BigInt(userId) }
+            } : false
+          }
+        }
+      }
+    });
+  },
+
+  /**
+   * 작가의 팔로워 수 조회
+   */
+  async countFollowersByArtistId(artistId) {
+    return await prisma.follow.count({
+      where: {
+        artistId: BigInt(artistId)
+      }
+    });
+  },
+
+  /**
+   * 작가의 완료된 작업 수 조회
+   */
+  async countCompletedWorksByArtistId(artistId) {
+    return await prisma.request.count({
+      where: {
+        commission: {
+          artistId: BigInt(artistId)
+        },
+        status: 'COMPLETED'
+      }
+    });
+  },
+
+  /**
+   * 작가의 리뷰 통계 조회
+   */
+  async getReviewStatsByArtistId(artistId) {
+    const reviews = await prisma.review.findMany({
+      where: {
+        request: {
+          commission: {
+            artistId: BigInt(artistId)
+          }
+        }
+      },
+      select: {
+        rate: true
+      }
+    });
+
+    return reviews;
+  },
+
+  /**
+   * 작가의 리뷰 목록 조회 (페이지네이션, 이미지 포함)
+   */
+  async findReviewsByArtistId(artistId, page, limit) {
+    const skip = (page - 1) * limit;
+    
+    return await prisma.review.findMany({
+      where: {
+        request: {
+          commission: {
+            artistId: BigInt(artistId)
+          }
+        }
+      },
+      include: {
+        user: {
+          select: {
+            nickname: true
+          }
+        },
+        request: {
+          include: {
+            commission: {
+              select: {
+                title: true
+              }
+            }
+          }
+        }
+      },
+      orderBy: {
+        createdAt: 'desc'
+      },
+      skip,
+      take: limit
+    });
+  },
+
+  /**
+   * 작가의 전체 리뷰 수 조회
+   */
+  async countReviewsByArtistId(artistId) {
+    return await prisma.review.count({
+      where: {
+        request: {
+          commission: {
+            artistId: BigInt(artistId)
+          }
+        }
+      }
+    });
+  },
+
+  /**
+   * 리뷰 이미지 조회
+   */
+  async findImagesByReviewId(reviewId) {
+    return await prisma.image.findMany({
+      where: {
+        target: 'review',
+        targetId: BigInt(reviewId)
+      },
+      orderBy: { orderIndex: 'asc' }
+    });
   }
 }

src/commission/service/commission.service.js

@@ -439,5 +439,172 @@ export const CommissionService = {
         });
       }
     }
+  },
+
+  /**
+   * 커미션 게시글 작가 정보 조회
+   */
+  async getCommissionArtistInfo(userId, dto) {
+    const { commissionId, page, limit } = dto;
+
+    // 1. 커미션 존재 여부 확인 및 작가 정보 조회
+    const commission = await CommissionRepository.findArtistInfoByCommissionId(commissionId, userId);
+    if (!commission) {
+      throw new CommissionNotFoundError({ commissionId });
+    }
+
+    const artistId = commission.artist.id;
+
+    // 2. 작가 통계 정보 조회 (병렬 처리)
+    const [followerCount, completedWorksCount, reviewStats, reviews, totalReviews] = await Promise.all([
+      CommissionRepository.countFollowersByArtistId(artistId),
+      CommissionRepository.countCompletedWorksByArtistId(artistId), 
+      CommissionRepository.getReviewStatsByArtistId(artistId),
+      CommissionRepository.findReviewsByArtistId(artistId, page, limit),
+      CommissionRepository.countReviewsByArtistId(artistId)
+    ]);
+
+    // 3. 리뷰 통계 계산
+    const { averageRate, recommendationRate } = this.calculateReviewStatistics(reviewStats);
+
+    // 4. 리뷰 데이터 처리 (이미지 포함)
+    const processedReviews = await this.processReviews(reviews);
+
+    // 5. 페이지네이션 정보 계산
+    const totalPages = Math.ceil(totalReviews / limit);
+
+    return {
+      artist: {
+        artistId: commission.artist.id,
+        nickname: commission.artist.nickname,
+        profileImageUrl: commission.artist.profileImage,
+        follower: followerCount,
+        completedworks: completedWorksCount
+      },
+      isFollowing: commission.artist.follows?.length > 0 || false,
+      reviewStatistics: {
+        averageRate: averageRate,
+        totalReviews: totalReviews,
+        recommendationRate: recommendationRate
+      },
+      recentReviews: processedReviews,
+      pagination: {
+        page: page,
+        limit: limit,
+        total: totalReviews,
+        totalPages: totalPages
+      }
+    };
+  },
+
+  /**
+   * 리뷰 통계 계산
+   */
+  calculateReviewStatistics(reviewStats) {
+    if (reviewStats.length === 0) {
+      return {
+        averageRate: 0.0,
+        recommendationRate: 0
+      };
+    }
+
+    // 평균 별점 계산 (소수점 1자리)
+    const totalRate = reviewStats.reduce((sum, review) => sum + review.rate, 0);
+    const averageRate = Math.round((totalRate / reviewStats.length) * 10) / 10;
+
+    // 추천율 계산 (평균별점 * 20)
+    const recommendationRate = Math.round(averageRate * 20);
+
+    return {
+      averageRate,
+      recommendationRate
+    };
+  },
+
+  /**
+   * 리뷰 데이터 처리 (이미지, 작업기간, 상대시간 포함)
+   */
+  async processReviews(reviews) {
+    const processedReviews = [];
+
+    for (const review of reviews) {
+      // 리뷰 이미지 조회
+      const images = await CommissionRepository.findImagesByReviewId(review.id);
+
+      // 작업 기간 계산
+      const workperiod = this.calculateWorkPeriod(
+        review.request.inProgressAt,
+        review.request.completedAt
+      );
+
+      // 상대 시간 계산
+      const timeAgo = this.calculateTimeAgo(review.createdAt);
+
+      processedReviews.push({
+        id: review.id,
+        rate: review.rate,
+        content: review.content,
+        userNickname: review.user.nickname,
+        commissionTitle: review.request.commission.title,
+        workperiod: workperiod,
+        createdAt: review.createdAt.toISOString(),
+        timeAgo: timeAgo,
+        images: images.map(img => ({
+          id: img.id,
+          imageUrl: img.imageUrl,
+          orderIndex: img.orderIndex
+        }))
+      });
+    }
+
+    return processedReviews;
+  },
+
+  /**
+   * 작업 기간 계산
+   */
+  calculateWorkPeriod(inProgressAt, completedAt) {
+    if (!inProgressAt || !completedAt) {
+      return null;
+    }
+
+    const diffMs = new Date(completedAt) - new Date(inProgressAt);
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffMinutes = Math.floor(diffMs / (1000 * 60));
+
+    if (diffDays >= 30) {
+      const months = Math.floor(diffDays / 30);
+      return `${months}달`;
+    } else if (diffDays >= 1) {
+      return `${diffDays}일`;
+    } else if (diffHours >= 1) {
+      return `${diffHours}시간`;
+    } else {
+      return `${diffMinutes}분`;
+    }
+  },
+
+  /**
+   * 상대 시간 계산 (n일 전, n달 전)
+   */
+  calculateTimeAgo(createdAt) {
+    const now = new Date();
+    const created = new Date(createdAt);
+    const diffMs = now - created;
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffMinutes = Math.floor(diffMs / (1000 * 60));
+
+    if (diffDays >= 30) {
+      const months = Math.floor(diffDays / 30);
+      return `${months}달 전`;
+    } else if (diffDays >= 1) {
+      return `${diffDays}일 전`;
+    } else if (diffHours >= 1) {
+      return `${diffHours}시간 전`;
+    } else {
+      return `${diffMinutes}분 전`;
+    }
   }
 };