category

src/modules/foods/providers/category.service.ts

@@ -3,7 +3,7 @@ import { CreateCategoryDto } from '../dto/create-category.dto';
 import { UpdateCategoryDto } from '../dto/update-category.dto';
 import { CategoryRepository } from '../repositories/category.repository';
 import { EntityManager } from '@mikro-orm/postgresql';
-import { RequiredEntityData, FilterQuery } from '@mikro-orm/core';
+import { RequiredEntityData } from '@mikro-orm/core';
 import { Category } from '../entities/category.entity';
 import { CategoryMessage, RestMessage } from 'src/common/enums/message.enum';
 import { Restaurant } from 'src/modules/restaurants/entities/restaurant.entity';
@@ -15,12 +15,15 @@ export class CategoryService {
     private readonly em: EntityManager,
   ) {}
 
-  async create(dto: CreateCategoryDto): Promise<Category> {
+  async create(restId: string, dto: CreateCategoryDto): Promise<Category> {
+    const restaurant = await this.em.findOne(Restaurant, { id: restId });
+    if (!restaurant) {
+      throw new NotFoundException(RestMessage.NOT_FOUND);
+    }
     const data: RequiredEntityData<Category> = {
       title: dto.title,
       isActive: dto.isActive ?? true,
-      //TODO
-      restId: '01KA35CFFN0F6VA04DF0W6KCE3',
+      restaurant: restaurant,
       avatarUrl: dto.avatarUrl,
     };
 
@@ -34,37 +37,41 @@ export class CategoryService {
     if (!restaurant || !restaurant.id) {
       throw new NotFoundException(RestMessage.NOT_FOUND);
     }
-    return this.categoryRepository.find({ restId: restaurant.id.toString() });
+    return this.categoryRepository.find({ restaurant: restaurant });
   }
 
-  async findAll(opts?: { restId?: string; isActive?: boolean }): Promise<Category[]> {
-    const where: FilterQuery<Category> = {};
-    if (opts?.restId) where.restId = opts.restId;
-    if (opts && typeof opts.isActive === 'boolean') where.isActive = opts.isActive;
-    const cats = await this.categoryRepository.find(where, { populate: ['foods'] });
-
-    // Return plain objects to avoid circular references during JSON serialization
-    return cats.map(cat => ({
-      id: cat.id,
-      title: cat.title,
-      isActive: cat.isActive,
-      restId: cat.restId,
-      avatarUrl: cat.avatarUrl,
-      createdAt: cat.createdAt,
-      updatedAt: cat.updatedAt,
-      foods: cat.foods.getItems().map(f => ({ id: f.id, title: f.title })),
-    })) as unknown as Category[];
+  async findAllByRestaurantId(restId: string): Promise<Category[]> {
+    return this.categoryRepository.find({ restaurant: { id: restId } });
   }
 
+  // async findAll(opts?: { restId?: string; isActive?: boolean }): Promise<Category[]> {
+  //   const where: FilterQuery<Category> = {};
+  //   if (opts?.restId) where.restId = opts.restId;
+  //   if (opts && typeof opts.isActive === 'boolean') where.isActive = opts.isActive;
+  //   const cats = await this.categoryRepository.find(where, { populate: ['foods'] });
+
+  //   // Return plain objects to avoid circular references during JSON serialization
+  //   return cats.map(cat => ({
+  //     id: cat.id,
+  //     title: cat.title,
+  //     isActive: cat.isActive,
+  //     restId: cat.restId,
+  //     avatarUrl: cat.avatarUrl,
+  //     createdAt: cat.createdAt,
+  //     updatedAt: cat.updatedAt,
+  //     foods: cat.foods.getItems().map(f => ({ id: f.id, title: f.title })),
+  //   })) as unknown as Category[];
+  // }
+
   async findOne(restId: string, id: string): Promise<Category> {
-    const cat = await this.categoryRepository.findOne({ id, restId }, { populate: ['foods'] });
+    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } }, { populate: ['foods'] });
     if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
 
     return {
       id: cat.id,
       title: cat.title,
       isActive: cat.isActive,
-      restId: cat.restId,
+      restaurant: cat.restaurant,
       avatarUrl: cat.avatarUrl,
       createdAt: cat.createdAt,
       updatedAt: cat.updatedAt,
@@ -73,14 +80,14 @@ export class CategoryService {
   }
 
   async findRestaurantCategories(restId: string): Promise<Category> {
-    const cat = await this.categoryRepository.findOne({ restId }, { populate: ['foods'] });
+    const cat = await this.categoryRepository.findOne({ restaurant: { id: restId } }, { populate: ['foods'] });
     if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
 
     return {
       id: cat.id,
       title: cat.title,
       isActive: cat.isActive,
-      restId: cat.restId,
+      restaurant: cat.restaurant,
       avatarUrl: cat.avatarUrl,
       createdAt: cat.createdAt,
       updatedAt: cat.updatedAt,
@@ -88,7 +95,7 @@ export class CategoryService {
   }
 
   async update(restId: string, id: string, dto: UpdateCategoryDto): Promise<Category> {
-    const cat = await this.categoryRepository.findOne({ id, restId });
+    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } });
     if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
     this.em.assign(cat, dto);
     await this.em.persistAndFlush(cat);
@@ -96,7 +103,7 @@ export class CategoryService {
   }
 
   async remove(restId: string, id: string): Promise<void> {
-    const cat = await this.categoryRepository.findOne({ id, restId });
+    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } });
     if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
     cat.deletedAt = new Date();
     await this.em.persistAndFlush(cat);