@hedhog/admin 0.0.104 → 0.0.105

package/src/route/route.service.spec.ts

@@ -0,0 +1,299 @@
+import {
+  PageOrderDirection,
+  PaginationDTO,
+  PaginationService,
+} from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { Test, TestingModule } from '@nestjs/testing';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { RouteService } from './route.service';
+
+describe('RouteService', () => {
+  let service: RouteService;
+  let prismaService: PrismaService;
+  let paginationService: PaginationService;
+
+  const mockPrismaService = {
+    route: {
+      findUnique: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    role_route: {
+      deleteMany: jest.fn(),
+      createMany: jest.fn(),
+    },
+    route_screens: {
+      deleteMany: jest.fn(),
+      createMany: jest.fn(),
+    },
+    createInsensitiveSearch: jest.fn(),
+  };
+
+  const mockPaginationService = {
+    paginate: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        RouteService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: PaginationService, useValue: mockPaginationService },
+      ],
+    }).compile();
+
+    service = module.get<RouteService>(RouteService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getRoutes', () => {
+    it('should paginate route', async () => {
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+      const result = { data: [], total: 0 };
+
+      mockPrismaService.createInsensitiveSearch.mockReturnValue([]);
+      mockPaginationService.paginate.mockResolvedValue(result);
+
+      const res = await service.getRoutes(paginationParams);
+
+      expect(mockPrismaService.createInsensitiveSearch).toHaveBeenCalledWith(
+        ['url', 'method'],
+        paginationParams,
+      );
+      expect(mockPaginationService.paginate).toHaveBeenCalledWith(
+        mockPrismaService.route,
+        paginationParams,
+        { where: { OR: [] } },
+      );
+      expect(res).toEqual(result);
+    });
+  });
+
+  describe('getRouteById', () => {
+    it('should return a route by ID', async () => {
+      const routeId = 1;
+      const route = { id: routeId, url: '/test', method: 'GET' };
+
+      mockPrismaService.route.findUnique.mockResolvedValue(route);
+
+      const res = await service.getRouteById(routeId);
+
+      expect(mockPrismaService.route.findUnique).toHaveBeenCalledWith({
+        where: { id: routeId },
+      });
+      expect(res).toEqual(route);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new route', async () => {
+      const createDto: CreateDTO = { url: '/test', method: 'GET' };
+      const route = { id: 1, ...createDto };
+
+      mockPrismaService.route.create.mockResolvedValue(route);
+
+      const res = await service.create(createDto);
+
+      expect(mockPrismaService.route.create).toHaveBeenCalledWith({
+        data: createDto,
+      });
+      expect(res).toEqual(route);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a route', async () => {
+      const updateDto: UpdateDTO = { url: '/updated', method: 'POST' };
+      const routeId = 1;
+      const updatedRoute = { id: routeId, ...updateDto };
+
+      mockPrismaService.route.update.mockResolvedValue(updatedRoute);
+
+      const res = await service.update({ id: routeId, data: updateDto });
+
+      expect(mockPrismaService.route.update).toHaveBeenCalledWith({
+        where: { id: routeId },
+        data: updateDto,
+      });
+      expect(res).toEqual(updatedRoute);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete route by ids', async () => {
+      const deleteDto: DeleteDTO = { ids: [1, 2] };
+      const result = { count: 2 };
+
+      mockPrismaService.route.deleteMany.mockResolvedValue(result);
+
+      const res = await service.delete(deleteDto);
+
+      expect(mockPrismaService.route.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: deleteDto.ids } },
+      });
+      expect(res).toEqual(result);
+    });
+  });
+
+  describe('updateRoles', () => {
+    it('should update role for a route', async () => {
+      const routeId = 1;
+      const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
+      const result = { count: 2 };
+
+      mockPrismaService.role_route.deleteMany.mockResolvedValue({});
+      mockPrismaService.role_route.createMany.mockResolvedValue(result);
+
+      const res = await service.updateRoles(routeId, updateIdsDto);
+
+      expect(mockPrismaService.role_route.deleteMany).toHaveBeenCalledWith({
+        where: { route_id: routeId },
+      });
+      expect(mockPrismaService.role_route.createMany).toHaveBeenCalledWith({
+        data: updateIdsDto.ids.map((roleId) => ({
+          role_id: roleId,
+          route_id: routeId,
+        })),
+        skipDuplicates: true,
+      });
+      expect(res).toEqual(result);
+    });
+  });
+
+  describe('updateScreens', () => {
+    it('should update screens for a route', async () => {
+      const routeId = 1;
+      const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
+      const result = { count: 2 };
+
+      mockPrismaService.route_screens.deleteMany.mockResolvedValue({});
+      mockPrismaService.route_screens.createMany.mockResolvedValue(result);
+
+      const res = await service.updateScreens(routeId, updateIdsDto);
+
+      expect(mockPrismaService.route_screens.deleteMany).toHaveBeenCalledWith({
+        where: { route_id: routeId },
+      });
+      expect(mockPrismaService.route_screens.createMany).toHaveBeenCalledWith({
+        data: updateIdsDto.ids.map((screenId) => ({
+          screen_id: screenId,
+          route_id: routeId,
+        })),
+        skipDuplicates: true,
+      });
+      expect(res).toEqual(result);
+    });
+  });
+
+  describe('listRoles', () => {
+    it('should call paginate method with correct parameters', async () => {
+      const locale = 'en';
+      const routeId = 1;
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      paginationService.paginate = jest.fn().mockResolvedValue({
+        data: [],
+        total: 0,
+      });
+
+      await service.listRoles(locale, routeId, paginationParams);
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.role,
+        paginationParams,
+        {
+          include: {
+            role_locale: {
+              where: {
+                locale: { code: locale },
+              },
+              select: {
+                name: true,
+                description: true,
+              },
+            },
+            role_route: {
+              where: { route_id: routeId },
+              select: {
+                route_id: true,
+                role_id: true,
+              },
+            },
+          },
+        },
+        'role_locale',
+      );
+    });
+  });
+
+  describe('listScreens', () => {
+    it('should call paginate method with correct parameters', async () => {
+      const locale = 'en';
+      const routeId = 1;
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      paginationService.paginate = jest.fn().mockResolvedValue({
+        data: [],
+        total: 0,
+      });
+
+      await service.listScreens(locale, routeId, paginationParams);
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.screens,
+        paginationParams,
+        {
+          include: {
+            screen_locale: {
+              where: {
+                locale: { code: locale },
+              },
+              select: {
+                name: true,
+              },
+            },
+            route_screens: {
+              where: { route_id: routeId },
+              select: {
+                route_id: true,
+                screen_id: true,
+              },
+            },
+          },
+        },
+        'screen_locale',
+      );
+    });
+  });
+});

package/src/route/route.service.ts

@@ -0,0 +1,164 @@
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class RouteService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async getRoutes(paginationParams: PaginationDTO) {
+    const fields = ['url', 'method'];
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    return this.paginationService.paginate(
+      this.prismaService.route,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+      },
+    );
+  }
+
+  async getRouteById(routeId: number) {
+    return this.prismaService.route.findUnique({ where: { id: routeId } });
+  }
+
+  async create({ url, method }: CreateDTO) {
+    return this.prismaService.route.create({ data: { url, method } });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.route.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    return this.prismaService.route.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async listRoles(
+    locale: string,
+    routeId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        include: {
+          role_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+          role_route: {
+            where: {
+              route_id: routeId,
+            },
+            select: {
+              route_id: true,
+              role_id: true,
+            },
+          },
+        },
+      },
+      'role_locale',
+    );
+  }
+
+  async updateRoles(routeId: number, data: UpdateIdsDTO) {
+    await this.prismaService.role_route.deleteMany({
+      where: {
+        route_id: routeId,
+      },
+    });
+
+    return this.prismaService.role_route.createMany({
+      data: data.ids.map((roleId) => ({
+        role_id: roleId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async listScreens(
+    locale: string,
+    routeId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+          route_screens: {
+            where: {
+              route_id: routeId,
+            },
+            select: {
+              route_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+  }
+
+  async updateScreens(routeId: number, data: UpdateIdsDTO) {
+    await this.prismaService.route_screen.deleteMany({
+      where: {
+        route_id: routeId,
+      },
+    });
+
+    return this.prismaService.route_screen.createMany({
+      data: data.ids.map((screenId) => ({
+        screen_id: screenId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+}

package/src/screen/dto/create.dto.ts

@@ -0,0 +1,19 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateDTO {
+  @IsString({ message: 'O nome deve ser uma string' })
+  @IsNotEmpty({ message: 'O nome é obrigatório.' })
+  name: string;
+
+  @IsString({ message: 'O slug deve ser uma string' })
+  @IsNotEmpty({ message: 'O slug é obrigatório.' })
+  slug: string;
+
+  @IsString({ message: 'A descrição deve ser uma string' })
+  @IsNotEmpty({ message: 'A descrição é obrigatória.' })
+  description: string;
+
+  @IsString({ message: 'O ícone deve ser uma string' })
+  @IsNotEmpty({ message: 'A descrição é obrigatória.' })
+  icon?: string;
+}

package/src/screen/dto/update.dto.ts

@@ -0,0 +1,19 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdateDTO {
+  @IsOptional()
+  @IsString({ message: 'O nome deve ser uma string' })
+  name?: string;
+
+  @IsOptional()
+  @IsString({ message: 'O slug deve ser uma string' })
+  slug?: string;
+
+  @IsOptional()
+  @IsString({ message: 'A descrição deve ser uma string' })
+  description?: string;
+
+  @IsOptional()
+  @IsString({ message: 'O ícone deve ser uma string' })
+  icon?: string;
+}

package/src/screen/screen.controller.ts

@@ -0,0 +1,93 @@
+import { Pagination } from '@hedhog/pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { Locale } from '../locale';
+import { Role } from '../role/decorators/role.decorator';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { ScreenService } from './screen.service';
+
+@Role()
+@Controller('screens')
+export class ScreenController {
+  constructor(
+    @Inject(forwardRef(() => ScreenService))
+    private readonly screenService: ScreenService,
+  ) {}
+
+  @Get()
+  async getScreens(@Pagination() paginationParams, @Locale() locale) {
+    return this.screenService.getScreens(locale, paginationParams);
+  }
+
+  @Get(':screenId/role')
+  async listRoles(
+    @Param('screenId', ParseIntPipe) screenId: number,
+    @Pagination() paginationParams,
+    @Locale() locale,
+  ) {
+    return this.screenService.listRoles(locale, screenId, paginationParams);
+  }
+
+  @Get(':screenId/route')
+  async listRoutes(
+    @Param('screenId', ParseIntPipe) screenId: number,
+    @Pagination() paginationParams,
+  ) {
+    return this.screenService.listRoutes(screenId, paginationParams);
+  }
+
+  @Patch(':screenId/role')
+  async updateRoles(
+    @Param('screenId', ParseIntPipe) screenId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.screenService.updateRoles(screenId, data);
+  }
+
+  @Patch(':screenId/route')
+  async updateRoutes(
+    @Param('screenId', ParseIntPipe) screenId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.screenService.updateRoutes(screenId, data);
+  }
+
+  @Get(':screenId')
+  async show(@Param('screenId', ParseIntPipe) screenId: number) {
+    return this.screenService.get(screenId);
+  }
+
+  @Post()
+  create(@Body() data: CreateDTO) {
+    return this.screenService.create(data);
+  }
+
+  @Patch(':screenId')
+  async update(
+    @Param('screenId', ParseIntPipe) screenId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.screenService.update({
+      id: screenId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.screenService.delete(data);
+  }
+}

package/src/screen/screen.module.ts

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