@hedhog/admin 0.46.39 → 0.46.40

package/src/route/route.service.ts

@@ -1,164 +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 list(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 get(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_screen: {
-            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,
-    });
-  }
-}
+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 list(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 get(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_screen: {
+            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

@@ -1,11 +1,11 @@
-import { IsNotEmpty, IsString } from 'class-validator';
-
-export class CreateDTO {
-  @IsString({ message: 'O slug deve ser uma string' })
-  @IsNotEmpty({ message: 'O slug é obrigatório.' })
-  slug: string;
-
-  @IsString({ message: 'O ícone deve ser uma string' })
-  @IsNotEmpty({ message: 'A descrição é obrigatória.' })
-  icon?: string;
-}
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateDTO {
+  @IsString({ message: 'O slug deve ser uma string' })
+  @IsNotEmpty({ message: 'O slug é obrigatório.' })
+  slug: 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

@@ -1,19 +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;
-}
+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

@@ -1,93 +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 '@hedhog/locale';
-import { Role } from '@hedhog/core';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { ScreenService } from './screen.service';
-
-@Role()
-@Controller('screen')
-export class ScreenController {
-  constructor(
-    @Inject(forwardRef(() => ScreenService))
-    private readonly screenService: ScreenService,
-  ) {}
-
-  @Get()
-  async list(@Pagination() paginationParams, @Locale() locale) {
-    return this.screenService.list(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);
-  }
-}
+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 '@hedhog/locale';
+import { Role } from '@hedhog/core';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { ScreenService } from './screen.service';
+
+@Role()
+@Controller('screen')
+export class ScreenController {
+  constructor(
+    @Inject(forwardRef(() => ScreenService))
+    private readonly screenService: ScreenService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams, @Locale() locale) {
+    return this.screenService.list(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

@@ -1,18 +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 {}
+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 {}