@hedhog/admin 0.12.2 → 0.12.4

package/src/screen/screen.service.ts

@@ -1,179 +1,179 @@
-import { PaginationDTO, PaginationService } from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-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 { UpdateDTO } from './dto/update.dto';
-
-@Injectable()
-export class ScreenService {
-  constructor(
-    @Inject(forwardRef(() => PrismaService))
-    private readonly prismaService: PrismaService,
-    @Inject(forwardRef(() => PaginationService))
-    private readonly paginationService: PaginationService,
-  ) {}
-
-  async updateRoles(screenId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_screen.deleteMany({
-      where: {
-        screen_id: screenId,
-      },
-    });
-
-    return this.prismaService.role_screen.createMany({
-      data: data.ids.map((roleId) => ({
-        screen_id: screenId,
-        role_id: roleId,
-      })),
-      skipDuplicates: true,
-    });
-  }
-  async updateRoutes(screenId: number, { ids }: UpdateIdsDTO) {
-    ids = (
-      await this.prismaService.route.findMany({
-        where: {
-          id: {
-            in: ids,
-          },
-        },
-        select: {
-          id: true,
-        },
-      })
-    ).map((route) => route.id);
-
-    await this.prismaService.route_screen.deleteMany({
-      where: {
-        screen_id: screenId,
-      },
-    });
-
-    return this.prismaService.route_screen.createMany({
-      data: ids.map((routeId) => ({
-        screen_id: screenId,
-        route_id: routeId,
-      })),
-      skipDuplicates: true,
-    });
-  }
-  async listRoutes(screenId: number, paginationParams: PaginationDTO) {
-    return this.paginationService.paginate(
-      this.prismaService.route,
-      paginationParams,
-      {
-        include: {
-          route_screen: {
-            where: {
-              screen_id: screenId,
-            },
-            select: {
-              route_id: true,
-              screen_id: true,
-            },
-          },
-        },
-      },
-    );
-  }
-
-  async listRoles(
-    locale: string,
-    screenId: number,
-    paginationParams: PaginationDTO,
-  ) {
-    return this.paginationService.paginate(
-      this.prismaService.role,
-      paginationParams,
-      {
-        include: {
-          role_screen: {
-            where: {
-              screen_id: screenId,
-            },
-            select: {
-              role_id: true,
-              screen_id: true,
-            },
-          },
-        },
-      },
-    );
-  }
-
-  async list(locale: string, paginationParams: PaginationDTO) {
-    const fields = ['slug', 'icon'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    const result = await this.paginationService.paginate(
-      this.prismaService.screen,
-      paginationParams,
-      {
-        where: {
-          OR,
-        },
-        include: {
-          screen_locale: {
-            where: {
-              locale: {
-                code: locale,
-              },
-            },
-            select: {
-              name: true,
-              description: true,
-            },
-          },
-        },
-      },
-      'screen_locale',
-    );
-
-    return result;
-  }
-
-  async get(screenId: number) {
-    return this.prismaService.screen.findUnique({ where: { id: screenId } });
-  }
-
-  async create({ slug, icon }: CreateDTO) {
-    return this.prismaService.screen.create({
-      data: {
-        slug,
-        icon,
-      },
-    });
-  }
-
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.screen.update({
-      where: { id },
-      data,
-    });
-  }
-
-  async delete({ ids }: DeleteDTO) {
-    if (ids == undefined || ids == null) {
-      throw new BadRequestException(
-        `You must select at least one screen to delete.`,
-      );
-    }
-
-    return this.prismaService.screen.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
-    });
-  }
-}
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+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 { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class ScreenService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) { }
+
+  async updateRoles(screenId: number, data: UpdateIdsDTO) {
+    await (this.prismaService as any).role_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return (this.prismaService as any).role_screen.createMany({
+      data: data.ids.map((roleId) => ({
+        screen_id: screenId,
+        role_id: roleId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async updateRoutes(screenId: number, { ids }: UpdateIdsDTO) {
+    ids = (
+      await (this.prismaService as any).route.findMany({
+        where: {
+          id: {
+            in: ids,
+          },
+        },
+        select: {
+          id: true,
+        },
+      })
+    ).map((route) => route.id);
+
+    await (this.prismaService as any).route_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return (this.prismaService as any).route_screen.createMany({
+      data: ids.map((routeId) => ({
+        screen_id: screenId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async listRoutes(screenId: number, paginationParams: PaginationDTO) {
+    return this.paginationService.paginate(
+      (this.prismaService as any).route,
+      paginationParams,
+      {
+        include: {
+          route_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              route_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async listRoles(
+    locale: string,
+    screenId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      (this.prismaService as any).role,
+      paginationParams,
+      {
+        include: {
+          role_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              role_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'icon'];
+    const OR: any[] = (this.prismaService as any).createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      (this.prismaService as any).screen,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+
+    return result;
+  }
+
+  async get(screenId: number) {
+    return (this.prismaService as any).screen.findUnique({ where: { id: screenId } });
+  }
+
+  async create({ slug, icon }: CreateDTO) {
+    return (this.prismaService as any).screen.create({
+      data: {
+        slug,
+        icon,
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return (this.prismaService as any).screen.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one screen to delete.`,
+      );
+    }
+
+    return (this.prismaService as any).screen.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/types/http-method.ts

@@ -1,8 +1,8 @@
-export type HttpMethod =
-  | 'GET'
-  | 'POST'
-  | 'PUT'
-  | 'DELETE'
-  | 'PATCH'
-  | 'OPTIONS'
-  | 'HEAD';
+export type HttpMethod =
+  | 'GET'
+  | 'POST'
+  | 'PUT'
+  | 'DELETE'
+  | 'PATCH'
+  | 'OPTIONS'
+  | 'HEAD';

package/src/user/constants/user.constants.ts

@@ -1 +1 @@
-export const SALT_ROUNDS = 10;
+export const SALT_ROUNDS = 10;

package/src/user/dto/create.dto.ts

@@ -1,24 +1,24 @@
-import { IsEmail, IsString, IsStrongPassword } from 'class-validator';
-
-export class CreateDTO {
-  @IsString({ message: 'O nome deve ser uma string' })
-  name: string;
-
-  @IsEmail({}, { message: 'O email deve ser um email válido' })
-  email: string;
-
-  @IsStrongPassword(
-    {
-      minLength: 6,
-      minLowercase: 1,
-      minUppercase: 0,
-      minNumbers: 0,
-      minSymbols: 0,
-    },
-    {
-      message:
-        'A senha deve ter pelo menos 6 caracteres, contendo pelo menos uma letra minúscula',
-    },
-  )
-  password: string;
-}
+import { IsEmail, IsString, IsStrongPassword } from 'class-validator';
+
+export class CreateDTO {
+  @IsString({ message: 'O nome deve ser uma string' })
+  name: string;
+
+  @IsEmail({}, { message: 'O email deve ser um email válido' })
+  email: string;
+
+  @IsStrongPassword(
+    {
+      minLength: 6,
+      minLowercase: 1,
+      minUppercase: 0,
+      minNumbers: 0,
+      minSymbols: 0,
+    },
+    {
+      message:
+        'A senha deve ter pelo menos 6 caracteres, contendo pelo menos uma letra minúscula',
+    },
+  )
+  password: string;
+}

package/src/user/dto/update.dto.ts

@@ -1,41 +1,41 @@
-import {
-  IsEmail,
-  IsInt,
-  IsOptional,
-  IsString,
-  IsStrongPassword,
-} from 'class-validator';
-
-export class UpdateDTO {
-  @IsString({ message: 'The name must be a string' })
-  @IsOptional()
-  name?: string;
-
-  @IsEmail({}, { message: 'The email must be a valid email' })
-  @IsOptional()
-  email?: string;
-
-  @IsOptional()
-  @IsStrongPassword(
-    {
-      minLength: 6,
-      minLowercase: 1,
-      minUppercase: 0,
-      minNumbers: 0,
-      minSymbols: 0,
-    },
-    {
-      message:
-        'The password must be at least 6 characters long and contain at least one lowercase',
-    },
-  )
-  password?: string;
-
-  @IsOptional()
-  @IsInt({ message: 'The multifactor_id must be an integer' })
-  multifactor_id?: number;
-
-  @IsOptional()
-  @IsString({ message: 'The code must be a string' })
-  code?: string;
-}
+import {
+  IsEmail,
+  IsInt,
+  IsOptional,
+  IsString,
+  IsStrongPassword,
+} from 'class-validator';
+
+export class UpdateDTO {
+  @IsString({ message: 'The name must be a string' })
+  @IsOptional()
+  name?: string;
+
+  @IsEmail({}, { message: 'The email must be a valid email' })
+  @IsOptional()
+  email?: string;
+
+  @IsOptional()
+  @IsStrongPassword(
+    {
+      minLength: 6,
+      minLowercase: 1,
+      minUppercase: 0,
+      minNumbers: 0,
+      minSymbols: 0,
+    },
+    {
+      message:
+        'The password must be at least 6 characters long and contain at least one lowercase',
+    },
+  )
+  password?: string;
+
+  @IsOptional()
+  @IsInt({ message: 'The multifactor_id must be an integer' })
+  multifactor_id?: number;
+
+  @IsOptional()
+  @IsString({ message: 'The code must be a string' })
+  code?: string;
+}

package/src/user/user.controller.ts

@@ -1,75 +1,75 @@
-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 { Role } from '@hedhog/core';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { UserService } from './user.service';
-
-@Role()
-@Controller('user')
-export class UserController {
-  constructor(
-    @Inject(forwardRef(() => UserService))
-    private readonly userService: UserService,
-  ) {}
-
-  @Get()
-  async list(@Pagination() paginationParams) {
-    return this.userService.list(paginationParams);
-  }
-
-  @Get(':userId/role')
-  async listRoles(
-    @Param('userId', ParseIntPipe) userId: number,
-    @Pagination() paginationParams,
-  ) {
-    return this.userService.listRoles(userId, paginationParams);
-  }
-
-  @Patch(':userId/role')
-  async updateRoles(
-    @Param('userId', ParseIntPipe) userId: number,
-    @Body() data: UpdateIdsDTO,
-  ) {
-    return this.userService.updateRoles(userId, data);
-  }
-
-  @Get(':userId')
-  async get(@Param('userId', ParseIntPipe) userId: number) {
-    return this.userService.get(userId);
-  }
-
-  @Post()
-  create(@Body() data: CreateDTO) {
-    return this.userService.create(data);
-  }
-
-  @Patch(':userId')
-  async update(
-    @Param('userId', ParseIntPipe) userId: number,
-    @Body() data: UpdateDTO,
-  ) {
-    return this.userService.update({
-      id: userId,
-      data,
-    });
-  }
-
-  @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.userService.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 { Role } from '@hedhog/core';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { UserService } from './user.service';
+
+@Role()
+@Controller('user')
+export class UserController {
+  constructor(
+    @Inject(forwardRef(() => UserService))
+    private readonly userService: UserService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams) {
+    return this.userService.list(paginationParams);
+  }
+
+  @Get(':userId/role')
+  async listRoles(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Pagination() paginationParams,
+  ) {
+    return this.userService.listRoles(userId, paginationParams);
+  }
+
+  @Patch(':userId/role')
+  async updateRoles(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.userService.updateRoles(userId, data);
+  }
+
+  @Get(':userId')
+  async get(@Param('userId', ParseIntPipe) userId: number) {
+    return this.userService.get(userId);
+  }
+
+  @Post()
+  create(@Body() data: CreateDTO) {
+    return this.userService.create(data);
+  }
+
+  @Patch(':userId')
+  async update(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.userService.update({
+      id: userId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.userService.delete(data);
+  }
+}