@hedhog/admin 0.0.104 → 0.0.106

package/src/auth/auth.service.ts

@@ -0,0 +1,175 @@
+import { MailService } from '@hedhog/mail';
+import { PrismaService } from '@hedhog/prisma';
+import {
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { compare } from 'bcrypt';
+import { ForgetDTO } from './dto/forget.dto';
+import { LoginDTO } from './dto/login.dto';
+import { OtpDTO } from './dto/otp.dto';
+import { MultifactorType } from './enums/multifactor-type.enum';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => JwtService))
+    private readonly jwt: JwtService,
+    @Inject(forwardRef(() => MailService))
+    private readonly mail: MailService,
+  ) {}
+
+  async verifyToken(token: string) {
+    return this.jwt.verifyAsync(token, {
+      secret: String(process.env.JWT_SECRET),
+    });
+  }
+
+  generateRandomString(length: number): string {
+    const characters =
+      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      const randomIndex = Math.floor(Math.random() * characters.length);
+      result += characters.charAt(randomIndex);
+    }
+    return result;
+  }
+
+  generateRandomNumber(): number {
+    const min = 100000;
+    const max = 999999;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  async loginWithEmailAndPassword(email: string, password: string) {
+    const user = await this.prisma.user.findFirst({
+      where: {
+        email,
+      },
+    });
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const isPasswordValid = await compare(password, user.password);
+
+    if (!isPasswordValid) {
+      throw new NotFoundException('Invalid password');
+    }
+
+    if (!user.multifactor_id) {
+      return this.getToken(user);
+    } else {
+      if (user.multifactor_id === MultifactorType.EMAIL) {
+        const code = this.generateRandomNumber();
+
+        await this.prisma.user.update({
+          where: {
+            id: user.id,
+          },
+          data: {
+            code: String(code),
+          },
+        });
+
+        await this.mail.send({
+          to: user.email,
+          subject: 'Login code',
+          body: `Your login code is ${code}`,
+        });
+      }
+
+      return {
+        token: this.jwt.sign({
+          id: user.id,
+          mfa: user.multifactor_id,
+        }),
+        mfa: true,
+      };
+    }
+  }
+
+  async getToken(user) {
+    delete user.password;
+
+    const payload = { user };
+
+    return {
+      token: this.jwt.sign(payload),
+    };
+  }
+
+  async forget({ email }: ForgetDTO) {
+    const user = await this.prisma.user.findFirst({
+      where: {
+        email,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const code = this.generateRandomString(32);
+
+    await this.prisma.user.update({
+      where: {
+        id: user.id,
+      },
+      data: {
+        code,
+      },
+    });
+
+    await this.mail.send({
+      to: email,
+      subject: 'Reset password',
+      body: `Reset your password by clicking <a href="${process.env.FRONTEND_URL}/reset-password/${code}">here</a>`,
+    });
+
+    return true;
+  }
+
+  async otp({ token, code }: OtpDTO) {
+    const data = this.jwt.decode(token);
+
+    const user = await this.prisma.user.findFirst({
+      where: {
+        id: data['id'],
+        code: String(code),
+      },
+    });
+
+    if (!user) {
+      throw new NotFoundException('Invalid code');
+    }
+
+    await this.prisma.user.update({
+      where: {
+        id: user.id,
+      },
+      data: {
+        code: null,
+      },
+    });
+
+    return this.getToken(user);
+  }
+
+  login({ email, password }: LoginDTO) {
+    return this.loginWithEmailAndPassword(email, password);
+  }
+
+  verify(id: number) {
+    return this.prisma.user.findUnique({ where: { id } });
+  }
+}

package/src/auth/decorators/public.decorator.ts

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

package/src/auth/decorators/user.decorator.ts

@@ -0,0 +1,17 @@
+import {
+  createParamDecorator,
+  ExecutionContext,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+export const User = createParamDecorator(
+  (field: string | null = null, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+
+    if (!request.auth || !request.auth.user) {
+      throw new UnauthorizedException(`User is not authenticated`);
+    }
+
+    return field ? request.auth.user[field] : request.auth.user;
+  },
+);

package/src/auth/dto/forget.dto.ts

@@ -0,0 +1,6 @@
+import { IsEmail } from 'class-validator';
+
+export class ForgetDTO {
+  @IsEmail()
+  email: string;
+}

package/src/auth/dto/login.dto.ts

@@ -0,0 +1,15 @@
+import { IsEmail, IsStrongPassword } from 'class-validator';
+
+export class LoginDTO {
+  @IsEmail()
+  email: string;
+
+  @IsStrongPassword({
+    minLength: 6,
+    minLowercase: 1,
+    minUppercase: 0,
+    minNumbers: 0,
+    minSymbols: 0,
+  })
+  password: string;
+}

package/src/auth/dto/otp.dto.ts

@@ -0,0 +1,11 @@
+import { IsInt, IsJWT, Max, Min } from 'class-validator';
+
+export class OtpDTO {
+  @Min(0)
+  @Max(999999)
+  @IsInt()
+  code: number;
+
+  @IsJWT()
+  token: string;
+}

package/src/auth/enums/multifactor-type.enum.ts

@@ -0,0 +1,4 @@
+export enum MultifactorType {
+  EMAIL = 1,
+  APP = 2,
+}

package/src/auth/guards/auth.guard.ts

@@ -0,0 +1,50 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Request } from 'express';
+import { AuthService } from '../auth.service';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(
+    private auth: AuthService,
+    private reflector: Reflector,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload = await this.auth.verifyToken(token);
+
+      request['auth'] = payload;
+    } catch (error) {
+      throw new UnauthorizedException(error);
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+
+    return type === 'Bearer' ? token : undefined;
+  }
+}

package/src/auth/types/user.type.ts

@@ -0,0 +1,8 @@
+export type User = {
+  id: number;
+  name: string;
+  email: string;
+  password: string;
+  created_at: string;
+  updated_at: string;
+};

package/src/dto/delete.dto.ts

@@ -0,0 +1,8 @@
+import { ArrayMinSize, IsArray, IsInt } from 'class-validator';
+
+export class DeleteDTO {
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsInt({ each: true })
+  ids: number[];
+}

package/src/dto/update-ids.dto.ts

@@ -0,0 +1,9 @@
+import { IsArray, IsInt } from 'class-validator';
+
+export class UpdateIdsDTO {
+  @IsInt({
+    each: true,
+  })
+  @IsArray()
+  ids: number[];
+}

package/src/dto/with-locale.dto.ts

@@ -0,0 +1,8 @@
+import { IsObject, IsOptional, ValidateNested } from 'class-validator';
+
+export class WithLocaleDTO {
+  @IsOptional()
+  @IsObject()
+  @ValidateNested({ each: true })
+  locale: Record<string, string>;
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+// Admin Module
+export * from './admin.module';
+
+// Auth Module
+export * from './auth/auth.service';
+export * from './auth/decorators/public.decorator';
+export * from './auth/decorators/user.decorator';
+export * from './auth/guards/auth.guard';
+
+// Menu Module
+export * from './menu/menu.service';
+
+// Permission Module
+export * from './role/decorators/role.decorator';
+export * from './role/guards/role.guard';
+export * from './role/role.service';
+
+// Screen Module
+export * from './screen/screen.service';
+
+// Screen Module
+export * from './setting/setting.service';
+
+// User Module
+export * from './user/constants/user.constants';
+export * from './user/user.service';
+
+// Locale Module
+export * from './locale/locale.decorator';
+export * from './locale/locale.service';
+
+export * from './dto/delete.dto';
+export * from './dto/update-ids.dto';
+export * from './dto/with-locale.dto';

package/src/locale/dto/create.dto.ts

@@ -0,0 +1,12 @@
+import { IsString } from 'class-validator';
+
+export class CreateDTO {
+  @IsString()
+  name: string;
+
+  @IsString()
+  code: string;
+
+  @IsString()
+  region: string;
+}

package/src/locale/dto/delete.dto.ts

@@ -0,0 +1,8 @@
+import { ArrayMinSize, IsArray, IsInt } from 'class-validator';
+
+export class DeleteDTO {
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsInt({ each: true })
+  ids: number[];
+}

package/src/locale/dto/set-enabled.dto.ts

@@ -0,0 +1,9 @@
+import { IsString, IsArray } from 'class-validator';
+
+export class SetEnabledDTO {
+  @IsArray()
+  @IsString({
+    each: true,
+  })
+  codes: string[];
+}

package/src/locale/dto/update.dto.ts

@@ -0,0 +1,15 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdateDTO {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  code?: string;
+
+  @IsString()
+  @IsOptional()
+  region?: string;
+}

package/src/locale/index.ts

@@ -0,0 +1,4 @@
+export * from './locale.module';
+export * from './locale.service';
+export * from './locale.controller';
+export * from './locale.decorator';

package/src/locale/locale.controller.ts

@@ -0,0 +1,79 @@
+import { Pagination } from '@hedhog/pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  forwardRef,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Put,
+} from '@nestjs/common';
+import { Public } from '../auth/decorators/public.decorator';
+import { Role } from '../role/decorators/role.decorator';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from './dto/delete.dto';
+import { SetEnabledDTO } from './dto/set-enabled.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { Locale } from './locale.decorator';
+import { LocaleService } from './locale.service';
+
+@Role()
+@Controller('locale')
+export class LocaleController {
+  constructor(
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+  ) {}
+
+  @Public()
+  @Get('system/enabled')
+  async listEnabled(@Pagination() paginationParams, @Locale() locale: string) {
+    return this.localeService.getEnables(locale, paginationParams);
+  }
+
+  @Public()
+  @Get(':localeCode/:namespace')
+  async getTranslations(
+    @Param('localeCode') localeCode: string,
+    @Param('namespace') namespace: string,
+  ) {
+    return this.localeService.getTranslations(localeCode, namespace);
+  }
+
+  @Get()
+  async get(@Pagination() paginationParams, @Locale() locale: string) {
+    return this.localeService.get(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async getById(@Param('id', ParseIntPipe) id: number) {
+    return this.localeService.getById(id);
+  }
+
+  @Post()
+  create(@Body() data: CreateDTO) {
+    return this.localeService.create(data);
+  }
+
+  @Put()
+  async setEnabled(@Body() { codes }: SetEnabledDTO) {
+    return this.localeService.setEnabled(codes);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.localeService.update({
+      id,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.localeService.delete(data);
+  }
+}

package/src/locale/locale.decorator.ts

@@ -0,0 +1,8 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const Locale = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request['locale'];
+  },
+);

package/src/locale/locale.middleware.ts

@@ -0,0 +1,34 @@
+import { PrismaService } from '@hedhog/prisma';
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+
+@Injectable()
+export class LocaleMiddleware implements NestMiddleware {
+  private languages = [];
+
+  constructor(private prisma: PrismaService) {}
+
+  async use(req: Request, _res: Response, next: NextFunction) {
+    const locale = req.headers['accept-language'] || 'en-US';
+    let code = locale.split(',')[0].split('-')[0];
+
+    if (!this.languages.length) {
+      const locale = await this.prisma.locale.findMany({
+        select: {
+          code: true,
+        },
+      });
+
+      for (const l of locale) {
+        this.languages.push(l.code);
+      }
+    }
+
+    if (!this.languages.includes(code)) {
+      code = 'en';
+    }
+
+    req['locale'] = code;
+    next();
+  }
+}

package/src/locale/locale.module.ts

@@ -0,0 +1,23 @@
+import { PaginationModule } from '@hedhog/pagination';
+import { PrismaModule } from '@hedhog/prisma';
+import { forwardRef, MiddlewareConsumer, Module } from '@nestjs/common';
+import { LocaleService } from './locale.service';
+import { LocaleController } from './locale.controller';
+import { LocaleMiddleware } from './locale.middleware';
+import { AuthModule } from '../auth/auth.module';
+
+@Module({
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [LocaleController],
+  providers: [LocaleService],
+  exports: [LocaleService],
+})
+export class LocaleModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(LocaleMiddleware).forRoutes('*');
+  }
+}