@hedhog/admin 0.51.16 → 0.51.21

package/src/auth/auth.service.ts

@@ -1,5 +1,6 @@
-import { MailService } from '@hedhog/mail';
+import { MailService as MailManagerService } from '@hedhog/mail-manager';
 import { PrismaService } from '@hedhog/prisma';
+import { HttpService } from '@nestjs/axios';
 import {
   BadRequestException,
   ConflictException,
@@ -13,14 +14,8 @@ import { ConfigService } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { compare, genSalt, hash } from 'bcrypt';
 import * as qrcode from 'qrcode';
+import { lastValueFrom } from 'rxjs';
 import * as speakeasy from 'speakeasy';
-import {
-  getChangeEmailEmail,
-  getChangePasswordEmail,
-  getCreateUserEmail,
-  getForgetPasswordEmail,
-  getResetPasswordEmail,
-} from '../emails';
 import { SettingService } from '../setting/setting.service';
 import { ChangeDTO } from './dto/change.dto';
 import { CreateUserDTO } from './dto/create-user.dto';
@@ -34,16 +29,17 @@ import { MultifactorType } from './enums/multifactor-type.enum';
 
 @Injectable()
 export class AuthService implements OnModuleInit {
-  private settings: Record<string, any> = {};
+  public settings: Record<string, any> = {};
 
   constructor(
+    private readonly httpService: HttpService,
     private readonly configService: ConfigService,
     @Inject(forwardRef(() => PrismaService))
     private readonly prisma: PrismaService,
     @Inject(forwardRef(() => JwtService))
     private readonly jwt: JwtService,
-    @Inject(forwardRef(() => MailService))
-    private readonly mail: MailService,
+    @Inject(forwardRef(() => MailManagerService))
+    private readonly mail: MailManagerService,
     @Inject(forwardRef(() => SettingService))
     private readonly setting: SettingService,
   ) {}
@@ -54,6 +50,10 @@ export class AuthService implements OnModuleInit {
       'mfa-window',
       'mfa-setp',
       'system-name',
+      'google_client_id',
+      'google_client_secret',
+      'google_scopes',
+      'url',
     ]);
   }
 
@@ -109,17 +109,20 @@ export class AuthService implements OnModuleInit {
     return this.getToken(newUser);
   }
 
-  async createUser({
-    code,
-    password,
-    street,
-    number,
-    complement,
-    district,
-    city,
-    state,
-    postal_code,
-  }: CreateUserDTO) {
+  async createUser(
+    locale: string,
+    {
+      code,
+      password,
+      street,
+      number,
+      complement,
+      district,
+      city,
+      state,
+      postal_code,
+    }: CreateUserDTO,
+  ) {
     try {
       const user = await this.createUserCheck(code);
       const salt = await genSalt();
@@ -184,12 +187,10 @@ export class AuthService implements OnModuleInit {
         });
       }
 
-      await this.mail.send({
-        to: user.email,
-        subject: 'Conta criada',
-        body: getCreateUserEmail({
-          name: user.name,
-        }),
+      await this.mail.sendTemplatedMail(locale, {
+        email: user.email,
+        slug: 'create-user',
+        variables: {},
       });
 
       return this.getToken(user);
@@ -221,7 +222,11 @@ export class AuthService implements OnModuleInit {
     return Math.floor(Math.random() * (max - min + 1)) + min;
   }
 
-  async loginWithEmailAndPassword(email: string, password: string) {
+  async loginWithEmailAndPassword(
+    locale: string,
+    email: string,
+    password: string,
+  ) {
     const user = await this.prisma.user.findFirst({
       where: {
         email,
@@ -237,8 +242,6 @@ export class AuthService implements OnModuleInit {
       throw new BadRequestException('Acesso negado');
     }
 
-    console.log('loginWithEmailAndPassword', { user });
-
     if (!user.multifactor_id) {
       return this.getToken(user);
     } else {
@@ -255,10 +258,10 @@ export class AuthService implements OnModuleInit {
             },
           });
 
-          await this.mail.send({
-            to: user.email,
-            subject: 'Código de Login',
-            body: `Seu código de login é ${code}`,
+          await this.mail.sendTemplatedMail(locale, {
+            email: user.email,
+            slug: 'login',
+            variables: { code: String(code) },
           });
 
           return {
@@ -290,7 +293,7 @@ export class AuthService implements OnModuleInit {
     };
   }
 
-  async forget({ email }: ForgetDTO) {
+  async forget(locale: string, { email }: ForgetDTO) {
     const appUrl =
       process.env.APP_URL ?? this.configService.get<string>('APP_URL');
 
@@ -319,10 +322,13 @@ export class AuthService implements OnModuleInit {
         },
       });
 
-      await this.mail.send({
-        to: email,
-        subject: `Recuperação de Senha`,
-        body: getForgetPasswordEmail(`${appUrl}/home?reset&code=${code}`),
+      await this.mail.sendTemplatedMail(locale, {
+        email,
+        slug: 'forget',
+        variables: {
+          appUrl,
+          code,
+        },
       });
     }
 
@@ -332,12 +338,10 @@ export class AuthService implements OnModuleInit {
     };
   }
 
-  async changePassword({
-    email,
-    currentPassword,
-    newPassword,
-    confirmNewPassword,
-  }: ChangeDTO) {
+  async changePassword(
+    locale: string,
+    { email, currentPassword, newPassword, confirmNewPassword }: ChangeDTO,
+  ) {
     if (newPassword !== confirmNewPassword) {
       throw new BadRequestException('Senhas não conferem');
     }
@@ -362,16 +366,19 @@ export class AuthService implements OnModuleInit {
       },
     });
 
-    await this.mail.send({
-      to: email,
-      subject: `Senha alterada`,
-      body: getChangePasswordEmail(),
+    await this.mail.sendTemplatedMail(locale, {
+      email,
+      slug: 'change-password',
+      variables: {},
     });
 
     return this.getToken(newUser);
   }
 
-  async changeEmail({ currentEmail, password, newEmail }: EmailDTO) {
+  async changeEmail(
+    locale: string,
+    { currentEmail, password, newEmail }: EmailDTO,
+  ) {
     const user = await this.prisma.user.findFirst({
       where: { email: currentEmail },
     });
@@ -419,16 +426,19 @@ export class AuthService implements OnModuleInit {
       data: { value: newEmail },
     });
 
-    await this.mail.send({
-      to: newEmail,
-      subject: `Email alterado`,
-      body: getChangeEmailEmail(),
+    await this.mail.sendTemplatedMail(locale, {
+      email: newEmail,
+      slug: 'change-email',
+      variables: {},
     });
 
     return this.getToken(newUser);
   }
 
-  async resetPassword({ code, newPassword, confirmNewPassword }: ResetDTO) {
+  async resetPassword(
+    locale: string,
+    { code, newPassword, confirmNewPassword }: ResetDTO,
+  ) {
     if (newPassword !== confirmNewPassword) {
       throw new BadRequestException('Senhas não conferem');
     }
@@ -459,10 +469,10 @@ export class AuthService implements OnModuleInit {
           },
         });
 
-        await this.mail.send({
-          to: user.email,
-          subject: `Senha recuperada`,
-          body: getResetPasswordEmail(),
+        await this.mail.sendTemplatedMail(locale, {
+          email: user.email,
+          slug: 'reset-password',
+          variables: {},
         });
 
         return this.getToken(user);
@@ -513,7 +523,6 @@ export class AuthService implements OnModuleInit {
 
     switch (data.mfa) {
       case MultifactorType.EMAIL:
-      //TO DO
       case MultifactorType.APP:
         const codes = await this.prisma.user_code_recovery.findMany({
           where: {
@@ -602,8 +611,8 @@ export class AuthService implements OnModuleInit {
     }
   }
 
-  async login({ email, password }: LoginDTO) {
-    return this.loginWithEmailAndPassword(email, password);
+  async login(locale: string, { email, password }: LoginDTO) {
+    return this.loginWithEmailAndPassword(locale, email, password);
   }
 
   async verify(id: number) {
@@ -764,4 +773,86 @@ export class AuthService implements OnModuleInit {
 
     return { ...this.getToken(user), codes };
   }
+
+  async loginGoogle(res: any) {
+    const redirectURI = new URL(
+      '/auth/google/callback',
+      this.settings['url'],
+    ).toString();
+
+    const params = new URLSearchParams({
+      client_id: this.settings['google_client_id'],
+      redirect_uri: redirectURI,
+      response_type: 'code',
+      scope: this.settings['google_scopes'].join(' '),
+    });
+
+    const url = `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+
+    return res.redirect(url);
+  }
+
+  async callbackGoogle(code: string) {
+    const tokenUrl = 'https://oauth2.googleapis.com/token';
+    const profileUrl = 'https://www.googleapis.com/oauth2/v2/userinfo';
+
+    const tokenResponse = await this.fetchGoogleToken(code, tokenUrl);
+    const profile = await this.fetchGoogleProfile(
+      tokenResponse.access_token,
+      profileUrl,
+    );
+
+    let user = await this.findOrCreateUser(profile);
+
+    return this.getToken(user);
+  }
+
+  private async fetchGoogleToken(code: string, url: string) {
+    const response = await lastValueFrom(
+      this.httpService.post(
+        url,
+        {
+          client_id: this.settings['google_client_id'],
+          client_secret: this.settings['google_client_secret'],
+          redirect_uri: `${this.settings['url']}/auth/google/callback`,
+          grant_type: 'authorization_code',
+          code,
+        },
+        {
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        },
+      ),
+    );
+
+    return response.data;
+  }
+
+  private async fetchGoogleProfile(accessToken: string, url: string) {
+    const response = await lastValueFrom(
+      this.httpService.get(url, {
+        headers: { Authorization: `Bearer ${accessToken}` },
+      }),
+    );
+
+    return response.data;
+  }
+
+  private async findOrCreateUser(profile: any) {
+    let user = await this.prisma.user.findFirst({
+      where: { email: profile.email },
+    });
+
+    if (!user) {
+      user = await this.prisma.user.create({
+        data: {
+          email: profile.email,
+          name: profile.name,
+          password: '',
+          code: profile.id,
+        },
+      });
+    }
+
+    return user;
+  }
 }

package/src/dashboard/dashboard-component/dashboard-component.controller.ts

@@ -1,55 +1,55 @@
-import { Pagination } from '@hedhog/pagination';
-import { Locale } from '@hedhog/locale';
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Inject,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-  forwardRef
-} from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { DashboardComponentService } from './dashboard-component.service';
-import { Role, DeleteDTO } from '@hedhog/core';
-
-@Role()
-@Controller('dashboard-component')
-export class DashboardComponentController {
-  constructor(
-    @Inject(forwardRef(() => DashboardComponentService))
-    private readonly dashboardComponentService: DashboardComponentService
-  ) {}
-
-  @Get()
-  async list(@Locale() locale, @Pagination() paginationParams) {
-    return this.dashboardComponentService.list(locale, paginationParams);
-  }
-
-  @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.dashboardComponentService.get(id);
-  }
-
-  @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.dashboardComponentService.create(data);
-  }
-
-  @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
-    return this.dashboardComponentService.update({
-      id,
-      data
-    });
-  }
-
-  @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.dashboardComponentService.delete(data);
-  }
-}
+import { Pagination } from '@hedhog/pagination';
+import { Locale } from '@hedhog/locale';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DashboardComponentService } from './dashboard-component.service';
+import { Role, DeleteDTO } from '@hedhog/core';
+
+@Role()
+@Controller('dashboard-component')
+export class DashboardComponentController {
+  constructor(
+    @Inject(forwardRef(() => DashboardComponentService))
+    private readonly dashboardComponentService: DashboardComponentService
+  ) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.dashboardComponentService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.dashboardComponentService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.dashboardComponentService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.dashboardComponentService.update({
+      id,
+      data
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.dashboardComponentService.delete(data);
+  }
+}

package/src/dashboard/dashboard-component/dto/create.dto.ts

@@ -1,36 +1,36 @@
-import { IsString, IsNumber, IsBoolean, IsOptional } from 'class-validator';
-import { WithLocaleDTO } from '@hedhog/locale';
-
-export class CreateDTO extends WithLocaleDTO {
-  @IsString()
-  slug: string;
-
-  @IsString()
-  path: string;
-
-  @IsOptional()
-  @IsNumber()
-  min_width?: number;
-
-  @IsOptional()
-  @IsNumber()
-  max_width?: number;
-
-  @IsOptional()
-  @IsNumber()
-  min_height?: number;
-
-  @IsOptional()
-  @IsNumber()
-  max_height?: number;
-
-  @IsNumber()
-  width: number;
-
-  @IsNumber()
-  height: number;
-
-  @IsOptional()
-  @IsBoolean()
-  is_resizable?: boolean;
-}
+import { IsString, IsNumber, IsBoolean, IsOptional } from 'class-validator';
+import { WithLocaleDTO } from '@hedhog/locale';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString()
+  slug: string;
+
+  @IsString()
+  path: string;
+
+  @IsOptional()
+  @IsNumber()
+  min_width?: number;
+
+  @IsOptional()
+  @IsNumber()
+  max_width?: number;
+
+  @IsOptional()
+  @IsNumber()
+  min_height?: number;
+
+  @IsOptional()
+  @IsNumber()
+  max_height?: number;
+
+  @IsNumber()
+  width: number;
+
+  @IsNumber()
+  height: number;
+
+  @IsOptional()
+  @IsBoolean()
+  is_resizable?: boolean;
+}

package/src/dashboard/dashboard-component/dto/update.dto.ts

@@ -1,4 +1,4 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
-
-export class UpdateDTO extends PartialType(CreateDTO) {}
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/dashboard/dashboard-item/dto/update.dto.ts

@@ -1,4 +1,4 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
-
-export class UpdateDTO extends PartialType(CreateDTO) {}
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

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

@@ -1,4 +1,4 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
-
-export class UpdateDTO extends PartialType(CreateDTO) {}
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/dashboard/index.ts

@@ -1 +1 @@
-export * from './dashboard.module';
+export * from './dashboard.module';

package/src/setting/setting.service.ts

@@ -344,7 +344,7 @@ export class SettingService {
       },
     });
 
-    const slugUserOverride = setting.filter((setting) => setting.user_override);
+    const slugUserOverride = setting.filter((s) => s.user_override);
 
     const settingUser = await this.prismaService.setting_user.findMany({
       where: {
@@ -360,26 +360,31 @@ export class SettingService {
 
     const data: Record<string, any> = {};
 
-    setting.forEach((setting) => {
-      switch (setting.type) {
+    for (const s of setting) {
+      switch (s.type) {
         case 'boolean':
-          data[setting.slug] = setting.value === 'true';
+          data[s.slug] = s.value === 'true';
           break;
         case 'number':
-          data[setting.slug] = Number(setting.value);
+          data[s.slug] = Number(s.value);
           break;
         case 'array':
         case 'json':
-          data[setting.slug] = JSON.parse(setting.value);
+          try {
+            data[s.slug] = JSON.parse(s.value);
+          } catch (err) {
+            console.error('Error parsing JSON', s.value, err);
+            data[s.slug] = s.value;
+          }
           break;
         default:
-          data[setting.slug] = setting.value;
+          data[s.slug] = s.value;
       }
-    });
+    }
 
-    settingUser.forEach((setting) => {
-      data[slugUserOverride.find((s) => s.id === setting.setting_id).slug] =
-        setting.value;
+    settingUser.forEach((ss) => {
+      data[slugUserOverride.find((s) => s.id === ss.setting_id).slug] =
+        ss.value;
     });
 
     return data;