@hedhog/admin 0.0.104 → 0.0.105

package/src/menu/menu.module.ts

@@ -0,0 +1,18 @@
+import { AuthModule } from '../auth/auth.module';
+import { PaginationModule } from '@hedhog/pagination';
+import { PrismaModule } from '@hedhog/prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { MenuController } from './menu.controller';
+import { MenuService } from './menu.service';
+
+@Module({
+  providers: [MenuService],
+  exports: [MenuService],
+  controllers: [MenuController],
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+})
+export class MenuModule {}

package/src/menu/menu.service.spec.ts

@@ -0,0 +1,247 @@
+import {
+  PageOrderDirection,
+  PaginationDTO,
+  PaginationService,
+} from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { MenuService } from './menu.service';
+
+describe('MenuService', () => {
+  let menuService: MenuService;
+  let prismaService: PrismaService;
+  let paginationService: PaginationService;
+
+  const mockPrismaService = {
+    menu: {
+      create: jest.fn(),
+      update: jest.fn(),
+      deleteMany: jest.fn(),
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      count: jest.fn(),
+    },
+    role_menu: {
+      deleteMany: jest.fn(),
+      createMany: jest.fn(),
+    },
+    menu_screen: {
+      deleteMany: jest.fn(),
+      createMany: jest.fn(),
+    },
+  };
+
+  const mockPaginationService = {
+    paginate: jest.fn(),
+    createInsensitiveSearch: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        MenuService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: PaginationService, useValue: mockPaginationService },
+      ],
+    }).compile();
+
+    menuService = module.get<MenuService>(MenuService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('create', () => {
+    it('should create a new menu', async () => {
+      const createMenuDto = {
+        name: 'Test Menu',
+        url: '/test',
+        icon: 'test-icon',
+        order: 1,
+        menu_id: undefined,
+      };
+      mockPrismaService.menu.create.mockResolvedValue(createMenuDto);
+
+      const result = await menuService.create(createMenuDto);
+
+      expect(result).toEqual(createMenuDto);
+      expect(prismaService.menu.create).toHaveBeenCalledWith({
+        data: createMenuDto,
+      });
+    });
+  });
+
+  describe('update', () => {
+    it('should update a menu', async () => {
+      const updateDto = { id: 1, data: { name: 'Updated Menu' } };
+      mockPrismaService.menu.update.mockResolvedValue(updateDto.data);
+
+      const result = await menuService.update(updateDto);
+
+      expect(result).toEqual(updateDto.data);
+      expect(prismaService.menu.update).toHaveBeenCalledWith({
+        where: { id: updateDto.id },
+        data: updateDto.data,
+      });
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete menu', async () => {
+      const deleteDto = { ids: [1, 2, 3] };
+      mockPrismaService.menu.deleteMany.mockResolvedValue({ count: 3 });
+
+      const result = await menuService.delete(deleteDto);
+
+      expect(result).toEqual({ count: 3 });
+      expect(prismaService.menu.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: deleteDto.ids } },
+      });
+    });
+
+    it('should throw BadRequestException if no ids are provided', async () => {
+      await expect(menuService.delete({ ids: null })).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+  });
+
+  describe('listScreens', () => {
+    it('should paginate screens', async () => {
+      const locale = 'en';
+      const menuId = 1;
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      const mockScreens = [{ id: 1, name: 'Screen 1' }];
+      mockPaginationService.paginate.mockResolvedValue(mockScreens);
+
+      const result = await menuService.listScreens(
+        locale,
+        menuId,
+        paginationParams,
+      );
+
+      expect(result).toEqual(mockScreens);
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.screens,
+        paginationParams,
+        expect.anything(),
+        'screen_locale',
+      );
+    });
+  });
+
+  describe('updateScreens', () => {
+    it('should update screens associated with a menu', async () => {
+      const menuId = 1;
+      const updateData = { ids: [1, 2, 3] };
+
+      jest
+        .spyOn(prismaService.menu_screen, 'deleteMany')
+        .mockResolvedValue(null);
+      jest
+        .spyOn(prismaService.menu_screen, 'createMany')
+        .mockResolvedValue(null);
+
+      await menuService.updateScreens(menuId, updateData);
+
+      expect(prismaService.menu_screen.deleteMany).toHaveBeenCalledWith({
+        where: { menu_id: menuId },
+      });
+
+      expect(prismaService.menu_screen.createMany).toHaveBeenCalledWith({
+        data: updateData.ids.map((screenId) => ({
+          menu_id: menuId,
+          screen_id: screenId,
+        })),
+        skipDuplicates: true,
+      });
+    });
+  });
+
+  describe('updateRoles', () => {
+    it('should update role associated with a menu', async () => {
+      const menuId = 1;
+      const updateData = { ids: [1, 2] };
+
+      jest.spyOn(prismaService.role_menu, 'deleteMany').mockResolvedValue(null);
+      jest.spyOn(prismaService.role_menu, 'createMany').mockResolvedValue(null);
+
+      await menuService.updateRoles(menuId, updateData);
+
+      expect(prismaService.role_menu.deleteMany).toHaveBeenCalledWith({
+        where: { menu_id: menuId },
+      });
+
+      expect(prismaService.role_menu.createMany).toHaveBeenCalledWith({
+        data: updateData.ids.map((roleId) => ({
+          menu_id: menuId,
+          role_id: roleId,
+        })),
+        skipDuplicates: true,
+      });
+    });
+  });
+
+  describe('updateOrder', () => {
+    it('should update the order of menu', async () => {
+      const orderData = { ids: [1, 2, 3] };
+
+      jest.spyOn(prismaService.menu, 'count').mockResolvedValue(3);
+      jest.spyOn(prismaService.menu, 'update').mockResolvedValue(null);
+
+      await menuService.updateOrder(orderData);
+
+      expect(prismaService.menu.count).toHaveBeenCalledWith({
+        where: { id: { in: orderData.ids } },
+      });
+
+      expect(prismaService.menu.update).toHaveBeenCalledTimes(
+        orderData.ids.length,
+      );
+
+      orderData.ids.forEach((id, index) => {
+        expect(prismaService.menu.update).toHaveBeenCalledWith({
+          where: { id },
+          data: { order: index + 1 },
+        });
+      });
+    });
+
+    it('should throw BadRequestException if IDs are invalid', async () => {
+      const orderData = { ids: [1, 2, 3] };
+
+      jest.spyOn(prismaService.menu, 'count').mockResolvedValue(2); // IDs não batem com o número esperado
+
+      await expect(menuService.updateOrder(orderData)).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+  });
+  /*
+  describe('getMenus', () => {
+    it('should get menu for a user', async () => {
+      const locale = 'en';
+      const userId = 1;
+      const mockMenus = [{ id: 1, name: 'Menu 1' }];
+      mockPrismaService.menu.findMany.mockResolvedValue(mockMenus);
+
+      const result = await menuService.getMenus(locale, userId);
+
+      expect(result).toEqual(mockMenus);
+      expect(prismaService.menu.findMany).toHaveBeenCalled();
+    });
+  });
+  */
+});

package/src/menu/menu.service.ts

@@ -0,0 +1,263 @@
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { itemTranslations } from '@hedhog/utils';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { CreateDTO } from './dto/create.dto';
+import { OrderDTO } from './dto/order.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class MenuService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async updateScreens(menuId: number, data: UpdateIdsDTO) {
+    await this.prismaService.menu_screen.deleteMany({
+      where: {
+        menu_id: menuId,
+      },
+    });
+
+    return this.prismaService.menu_screen.createMany({
+      data: data.ids.map((screenId) => ({
+        menu_id: menuId,
+        screen_id: screenId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async updateRoles(menuId: number, data: UpdateIdsDTO) {
+    await this.prismaService.role_menu.deleteMany({
+      where: {
+        menu_id: menuId,
+      },
+    });
+
+    return this.prismaService.role_menu.createMany({
+      data: data.ids.map((roleId) => ({
+        menu_id: menuId,
+        role_id: roleId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async listScreens(
+    locale: string,
+    menuId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+          menu_screen: {
+            where: {
+              menu_id: menuId,
+            },
+            select: {
+              screen_id: true,
+              menu_id: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+  }
+  async listRoles(
+    locale: string,
+    menuId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        include: {
+          role_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+          role_menu: {
+            where: {
+              menu_id: menuId,
+            },
+            select: {
+              role_id: true,
+              menu_id: true,
+            },
+          },
+        },
+      },
+      'role_locale',
+    );
+  }
+
+  async getMenus(locale: string, userId: number, menuId = 0) {
+    if (menuId === 0) {
+      menuId = null;
+    }
+
+    let menu = (await this.prismaService.menu.findMany({
+      where: {
+        menu_id: menuId,
+        role_menu: {
+          some: {
+            role: {
+              role_user: {
+                some: {
+                  user_id: userId,
+                },
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        order: 'asc',
+      },
+      include: {
+        menu_locale: {
+          where: {
+            locale: {
+              code: locale,
+            },
+          },
+          select: {
+            name: true,
+          },
+        },
+      },
+    })) as unknown[] as any[];
+
+    menu = menu.map((m) => itemTranslations('menu_locale', m));
+
+    for (let i = 0; i < menu.length; i++) {
+      menu[i].menu = await this.getMenus(locale, userId, menu[i].id);
+    }
+
+    return menu;
+  }
+
+  async getSystemMenu(locale: string, userId: number) {
+    return this.getMenus(locale, userId);
+  }
+
+  async getMenu(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['url', 'icon'];
+    const OR = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    return this.paginationService.paginate(
+      this.prismaService.menu,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          menu_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+        },
+      },
+      'menu_locale',
+    );
+  }
+
+  async get(menuId: number) {
+    return this.prismaService.menu.findUnique({
+      where: { id: menuId },
+    });
+  }
+
+  async create({ name, url, icon, order, menuId }: CreateDTO) {
+    return this.prismaService.menu.create({
+      data: { name, url, icon, order, menu_id: menuId },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.menu.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one menu to delete.`,
+      );
+    }
+
+    return this.prismaService.menu.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async updateOrder({ ids }: OrderDTO): Promise<void> {
+    const count = await this.prismaService.menu.count({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+
+    if (count !== ids.length) {
+      throw new BadRequestException('IDs inválidos.');
+    }
+
+    await Promise.all(
+      ids.map((id, index) =>
+        this.prismaService.menu.update({
+          where: { id },
+          data: { order: index + 1 },
+        }),
+      ),
+    );
+  }
+}

package/src/role/decorators/role.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const WITH_ROLE = 'withRole';
+export const Role = () => SetMetadata(WITH_ROLE, true);

package/src/role/dto/create.dto.ts

@@ -0,0 +1,7 @@
+import { IsString } from 'class-validator';
+import { WithLocaleDTO } from '../../dto/with-locale.dto';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString()
+  slug: string;
+}

package/src/role/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/role/guards/role.guard.ts

@@ -0,0 +1,122 @@
+import { PrismaService } from '@hedhog/prisma';
+import {
+  CanActivate,
+  ExecutionContext,
+  forwardRef,
+  Inject,
+  Injectable,
+  RequestMethod,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { METHOD_METADATA } from '@nestjs/common/constants';
+import { Reflector } from '@nestjs/core';
+import { Request } from 'express';
+import { IS_PUBLIC_KEY } from '../../auth/decorators/public.decorator';
+import { WITH_ROLE } from '../decorators/role.decorator';
+
+@Injectable()
+export class RoleGuard implements CanActivate {
+  constructor(
+    private reflector: Reflector,
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    const withRole = this.reflector.getAllAndOverride<boolean>(WITH_ROLE, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (!withRole) {
+      return true;
+    }
+
+    const request = context.switchToHttp().getRequest<Request>();
+    const controller = context.getClass();
+    const handler = context.getHandler();
+    const controllerPath = this.reflector.get<string>('path', controller) || '';
+    const methodPath = this.reflector.get<string>('path', handler) || '';
+
+    const requestMethod = this.reflector.get<RequestMethod>(
+      METHOD_METADATA,
+      handler,
+    );
+
+    let fullPath = `/${controllerPath}/${methodPath}`.replace(/\/+/g, '/');
+
+    if (fullPath.endsWith('/')) {
+      fullPath = fullPath.slice(0, -1);
+    }
+
+    const token = this.extractTokenFromHeader(request);
+
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+
+    const userId = (request as any)?.auth?.user?.id;
+
+    let httpMethod: any;
+    switch (requestMethod) {
+      case RequestMethod.GET:
+        httpMethod = 'GET';
+        break;
+      case RequestMethod.POST:
+        httpMethod = 'POST';
+        break;
+      case RequestMethod.PUT:
+        httpMethod = 'PUT';
+        break;
+      case RequestMethod.DELETE:
+        httpMethod = 'DELETE';
+        break;
+      case RequestMethod.PATCH:
+        httpMethod = 'PATCH';
+        break;
+      case RequestMethod.OPTIONS:
+        httpMethod = 'OPTIONS';
+        break;
+      case RequestMethod.HEAD:
+        httpMethod = 'HEAD';
+        break;
+      case RequestMethod.ALL:
+        httpMethod = 'ALL';
+        break;
+    }
+
+    const route = await this.prisma.route.count({
+      where: {
+        method: httpMethod,
+        url: fullPath,
+        role_route: {
+          some: {
+            role: {
+              role_user: {
+                some: {
+                  user_id: Number(userId),
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return route === 1;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}