@hed-hog/core 0.0.4

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

@@ -0,0 +1,7 @@
+import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
+import { IsString } from 'class-validator';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString({ message: (args) => getLocaleText('validation.slugMustBeString', args.value) })
+  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,121 @@
+import { IS_PUBLIC_KEY, WITH_ROLE } from '@hed-hog/api';
+import { PrismaService } from '@hed-hog/api-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';
+
+@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(`Token not provided`);
+    }
+
+    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: userId,
+                }
+              }
+            }
+          }
+        },
+      },
+    });
+
+    return route === 1;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

package/src/role/role.controller.ts

@@ -0,0 +1,126 @@
+import { Pagination } from '@hed-hog/api-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 '@hed-hog/api-locale';
+import { Role } from '@hed-hog/api';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { RoleService } from './role.service';
+
+@Role()
+@Controller('role')
+export class RoleController {
+  constructor(
+    @Inject(forwardRef(() => RoleService))
+    private readonly roleService: RoleService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams, @Locale() locale) {
+    return this.roleService.list(locale, paginationParams);
+  }
+
+  @Get(':roleId/user')
+  async listUsers(
+    @Pagination() paginationParams,
+    @Param('roleId', ParseIntPipe) roleId: number,
+  ) {
+    return this.roleService.listUsers(roleId, paginationParams);
+  }
+
+  @Get(':roleId/menu')
+  async listMenus(
+    @Pagination() paginationParams,
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Locale() locale,
+  ) {
+    return this.roleService.listMenus(locale, roleId, paginationParams);
+  }
+
+  @Get(':roleId/route')
+  async listRoutes(
+    @Pagination() paginationParams,
+    @Param('roleId', ParseIntPipe) roleId: number,
+  ) {
+    return this.roleService.listRoutes(roleId, paginationParams);
+  }
+
+  @Get(':roleId/screen')
+  async listScreens(
+    @Pagination() paginationParams,
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Locale() locale,
+  ) {
+    return this.roleService.listScreens(locale, roleId, paginationParams);
+  }
+
+  @Patch(':roleId/user')
+  async updateUsers(
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.roleService.updateUsers(roleId, data);
+  }
+
+  @Patch(':roleId/menu')
+  async updateMenus(
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.roleService.updateMenus(roleId, data);
+  }
+
+  @Patch(':roleId/route')
+  async updateRoutes(
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.roleService.updateRoutes(roleId, data);
+  }
+
+  @Patch(':roleId/screen')
+  async updateScreens(
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.roleService.updateScreens(roleId, data);
+  }
+
+  @Get(':roleId')
+  async show(@Param('roleId', ParseIntPipe) roleId: number, @Locale() locale) {
+    return this.roleService.get(locale, roleId);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.roleService.create(data);
+  }
+
+  @Patch(':roleId')
+  async update(
+    @Param('roleId', ParseIntPipe) roleId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.roleService.update({
+      id: roleId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.roleService.delete(data);
+  }
+}

package/src/role/role.module.ts

@@ -0,0 +1,29 @@
+import { LocaleModule } from '@hed-hog/api-locale';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { APP_GUARD, Reflector } from '@nestjs/core';
+import { AuthModule } from '../auth/auth.module';
+import { RoleGuard } from './guards/role.guard';
+import { RoleController } from './role.controller';
+import { RoleService } from './role.service';
+
+@Module({
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => LocaleModule),
+  ],
+  controllers: [RoleController],
+  providers: [
+    Reflector,
+    RoleService,
+    {
+      provide: APP_GUARD,
+      useClass: RoleGuard,
+    },
+  ],
+  exports: [RoleService],
+})
+export class RoleModule {}

package/src/role/role.service.ts

@@ -0,0 +1,289 @@
+import { getWithLocale } from '@hed-hog/api';
+import { LocaleService, getLocaleText } from '@hed-hog/api-locale';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-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 RoleService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+  ) {}
+
+  async updateUsers(roleId: number, { ids }: UpdateIdsDTO):Promise<{count:number}> {
+    await this.prismaService.role_user.deleteMany({
+      where: {
+        role_id: roleId,
+      },
+    });
+
+    return this.prismaService.role_user.createMany({
+      data: ids.map((userId) => ({
+        role_id: roleId,
+        user_id: userId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async updateScreens(roleId: number, data: UpdateIdsDTO):Promise<{count:number}> {
+    await this.prismaService.role_screen.deleteMany({
+      where: {
+        role_id: roleId,
+      },
+    });
+
+    return this.prismaService.role_screen.createMany({
+      data: data.ids.map((screenId) => ({
+        role_id: roleId,
+        screen_id: screenId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async updateRoutes(roleId: number, data: UpdateIdsDTO):Promise<{count:number}> {
+    await this.prismaService.role_route.deleteMany({
+      where: {
+        role_id: roleId,
+      },
+    });
+
+    return this.prismaService.role_route.createMany({
+      data: data.ids.map((routeId) => ({
+        role_id: roleId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async updateMenus(roleId: number, data: UpdateIdsDTO):Promise<{count:number}> {
+    await this.prismaService.role_menu.deleteMany({
+      where: {
+        role_id: roleId,
+      },
+    });
+
+    return this.prismaService.role_menu.createMany({
+      data: data.ids.map((menuId) => ({
+        role_id: roleId,
+        menu_id: menuId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async listUsers(roleId: number, paginationParams: PaginationDTO) {
+    return this.paginationService.paginate(
+      this.prismaService.user,
+      paginationParams,
+      {
+        include: {
+          role_user: {
+            where: {
+              role_id: roleId,
+            },
+            select: {
+              user_id: true,
+              role_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async listMenus(
+    locale: string,
+    roleId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.menu,
+      paginationParams,
+      {
+        include: {
+          menu_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+          role_menu: {
+            where: {
+              role_id: roleId,
+            },
+            select: {
+              menu_id: true,
+              role_id: true,
+            },
+          },
+        },
+      },
+      'menu_locale',
+    );
+  }
+
+  async listRoutes(roleId: number, paginationParams: PaginationDTO) {
+    return this.paginationService.paginate(
+      this.prismaService.route,
+      paginationParams,
+      {
+        include: {
+          role_route: {
+            where: {
+              role_id: roleId,
+            },
+            select: {
+              route_id: true,
+              role_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async listScreens(
+    locale: string,
+    roleId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+          role_screen: {
+            where: {
+              role_id: roleId,
+            },
+            select: {
+              screen_id: true,
+              role_id: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const fields = [];
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          role_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'role_locale',
+    );
+  }
+
+  async get(locale: string, roleId: number) {
+    return getWithLocale(
+      locale,
+      'role_locale',
+      await this.prismaService.role.findUnique({
+        where: { id: roleId },
+        include: {
+          role_locale: {
+            where: {
+              locale: {
+                enabled: true,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+              locale: {
+                select: {
+                  code: true,
+                },
+              },
+            },
+          },
+        },
+      }),
+    );
+  }
+
+  async create({ slug }: CreateDTO) {
+    return this.localeService.createModelWithLocale('role', 'role_id', {
+      slug,
+    });
+  }
+
+  async update({ id, data: { slug } }: { id: number; data: UpdateDTO }) {
+    return this.localeService.updateModelWithLocale('role', 'role_id', id, {
+      slug,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO, locale: string = 'en'):Promise<{count:number}> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        getLocaleText('deleteItemsRequired', locale, 'You must select at least one permission to delete.'),
+      );
+    }
+
+    return this.prismaService.role.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/route/dto/create.dto.ts

@@ -0,0 +1,14 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+
+export class CreateDTO {
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  url: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsIn(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'], {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method: HttpMethod;
+}

package/src/route/dto/update.dto.ts

@@ -0,0 +1,16 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+
+export class UpdateDTO {
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  @IsOptional()
+  url?: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsOptional()
+  @IsIn(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'], {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method?: HttpMethod;
+}

package/src/route/route.controller.ts

@@ -0,0 +1,91 @@
+import { Pagination, PaginationDTO } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  forwardRef,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { Locale } from '@hed-hog/api-locale';
+import { Role } from '@hed-hog/api';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { RouteService } from './route.service';
+
+@Role()
+@Controller('route')
+export class RouteController {
+  constructor(
+    @Inject(forwardRef(() => RouteService))
+    private readonly routeService: RouteService,
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams) {
+    return this.routeService.list(paginationParams);
+  }
+
+  @Get(':routeId')
+  async get(@Param('routeId', ParseIntPipe) routeId: number) {
+    return this.routeService.get(routeId);
+  }
+
+  @Post()
+  async create(@Body() { url, method }: CreateDTO) {
+    return this.routeService.create({ url, method });
+  }
+
+  @Patch(':routeId')
+  async update(
+    @Param('routeId', ParseIntPipe) routeId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.routeService.update({ id: routeId, data });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.routeService.delete(data);
+  }
+
+  @Get(':routeId/role')
+  async listRoles(
+    @Param('routeId', ParseIntPipe) routeId: number,
+    @Pagination() paginationParams: PaginationDTO,
+    @Locale() locale,
+  ) {
+    return this.routeService.listRoles(locale, routeId, paginationParams);
+  }
+
+  @Patch(':routeId/role')
+  async updateRoles(
+    @Param('routeId', ParseIntPipe) routeId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.routeService.updateRoles(routeId, data);
+  }
+
+  @Get(':routeId/screens')
+  async listScreens(
+    @Param('routeId', ParseIntPipe) routeId: number,
+    @Pagination() paginationParams: PaginationDTO,
+    @Locale() locale,
+  ) {
+    return this.routeService.listScreens(locale, routeId, paginationParams);
+  }
+
+  @Patch(':routeId/screens')
+  async updateScreens(
+    @Param('routeId', ParseIntPipe) routeId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.routeService.updateScreens(routeId, data);
+  }
+}