review

src/modules/review/providers/review.service.ts

@@ -0,0 +1,159 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { CreateReviewDto } from '../dto/create-review.dto';
+import { UpdateReviewDto } from '../dto/update-review.dto';
+import { FindReviewsDto } from '../dto/find-reviews.dto';
+import { ReviewRepository } from '../repositories/review.repository';
+import { FoodRepository } from '../../foods/repositories/food.repository';
+import { UserRepository } from '../../users/repositories/user.repository';
+import { EntityManager } from '@mikro-orm/postgresql';
+import { RequiredEntityData } from '@mikro-orm/core';
+import { Review } from '../entities/review.entity';
+import { FoodMessage, UserMessage, ReviewMessage } from 'src/common/enums/message.enum';
+import { Order } from '../../orders/entities/order.entity';
+
+@Injectable()
+export class ReviewService {
+  constructor(
+    private readonly reviewRepository: ReviewRepository,
+    private readonly foodRepository: FoodRepository,
+    private readonly userRepository: UserRepository,
+    private readonly em: EntityManager,
+  ) {}
+
+  async create(userId: string, createReviewDto: CreateReviewDto): Promise<Review> {
+    const { foodId, orderId, rating, comment, positivePoints, negativePoints } = createReviewDto;
+
+    const food = await this.foodRepository.findOne({ id: foodId });
+    if (!food) {
+      throw new NotFoundException(FoodMessage.NOT_FOUND);
+    }
+
+    const user = await this.userRepository.findOne({ id: userId });
+    if (!user) {
+      throw new NotFoundException(UserMessage.USER_NOT_FOUND);
+    }
+
+    const order = await this.em.findOne(Order, { id: orderId });
+    if (!order) {
+      throw new NotFoundException('Order not found');
+    }
+
+    // Check if user already commented on this food for this order
+    const existingReview = await this.reviewRepository.findOne({
+      order: { id: orderId },
+      food: { id: foodId },
+      user: { id: userId },
+    });
+
+    if (existingReview) {
+      throw new BadRequestException(ReviewMessage.ALREADY_COMMENTED);
+    }
+
+    const data: RequiredEntityData<Review> = {
+      order,
+      food,
+      user,
+      rating,
+      comment: comment || undefined,
+      positivePoints: positivePoints || undefined,
+      negativePoints: negativePoints || undefined,
+      isApproved: false,
+    };
+
+    const review = this.reviewRepository.create(data);
+    if (!review) {
+      throw new Error('Failed to create review entity');
+    }
+
+    await this.em.persistAndFlush(review);
+
+    // Update food rating average
+    await this.updateFoodRating(foodId);
+
+    return review;
+  }
+
+  async findAll(dto: FindReviewsDto) {
+    return this.reviewRepository.findAllPaginated(dto);
+  }
+
+  async findById(id: string): Promise<Review> {
+    const review = await this.reviewRepository.findOne({ id }, { populate: ['food', 'user', 'order'] });
+    if (!review) {
+      throw new NotFoundException(ReviewMessage.NOT_FOUND);
+    }
+    return review;
+  }
+
+  async update(id: string, userId: string, dto: UpdateReviewDto, isAdmin: boolean = false): Promise<Review> {
+    const review = await this.reviewRepository.findOne({ id }, { populate: ['food', 'user', 'order'] });
+    if (!review) {
+      throw new NotFoundException(ReviewMessage.NOT_FOUND);
+    }
+
+    // Only allow user to update their own reviews (unless admin)
+    if (!isAdmin && review.user.id !== userId) {
+      throw new BadRequestException(ReviewMessage.CAN_ONLY_UPDATE_OWN);
+    }
+
+    // Users can only update rating and comment, not isApproved
+    if (!isAdmin && dto.isApproved !== undefined) {
+      throw new BadRequestException('Only admins can change approval status');
+    }
+
+    const oldRating = review.rating;
+    this.em.assign(review, dto);
+    await this.em.persistAndFlush(review);
+
+    // Update food rating average if rating changed
+    if (dto.rating !== undefined && dto.rating !== oldRating) {
+      await this.updateFoodRating(review.food.id);
+    }
+
+    return review;
+  }
+
+  async remove(id: string, userId: string, isAdmin: boolean = false) {
+    const review = await this.reviewRepository.findOne({ id }, { populate: ['food', 'user', 'order'] });
+    if (!review) {
+      throw new NotFoundException(ReviewMessage.NOT_FOUND);
+    }
+
+    // Only allow user to delete their own reviews (unless admin)
+    if (!isAdmin && review.user.id !== userId) {
+      throw new BadRequestException(ReviewMessage.CAN_ONLY_DELETE_OWN);
+    }
+
+    const foodId = review.food.id;
+    review.deletedAt = new Date();
+    await this.em.persistAndFlush(review);
+
+    // Update food rating average
+    await this.updateFoodRating(foodId);
+  }
+
+  private async updateFoodRating(foodId: string): Promise<void> {
+    const reviews = await this.reviewRepository.find(
+      { food: { id: foodId }, isApproved: true, deletedAt: null },
+      { fields: ['rating'] },
+    );
+
+    if (reviews.length === 0) {
+      const food = await this.foodRepository.findOne({ id: foodId });
+      if (food) {
+        food.rate = 0;
+        await this.em.persistAndFlush(food);
+      }
+      return;
+    }
+
+    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / reviews.length;
+
+    const food = await this.foodRepository.findOne({ id: foodId });
+    if (food) {
+      food.rate = parseFloat(averageRating.toFixed(2));
+      await this.em.persistAndFlush(food);
+    }
+  }
+}
+