@hed-hog/core 0.0.4

package/src/user/user.service.spec.ts

@@ -0,0 +1,294 @@
+// import {
+//   PageOrderDirection,
+//   PaginationDTO,
+//   PaginationService,
+// } from '@hed-hog/api-pagination';
+// import { PrismaService } from '@hed-hog/api-prisma';
+// import { BadRequestException } from '@nestjs/common';
+// import { Test, TestingModule } from '@nestjs/testing';
+// import { genSalt, hash } from 'bcrypt';
+// import { DeleteDTO } from '../dto/delete.dto';
+// import { UpdateIdsDTO } from '../dto/update-ids.dto';
+// import { SALT_ROUNDS } from './constants/user.constants';
+// import { CreateDTO } from './dto/create.dto';
+// import { UpdateDTO } from './dto/update.dto';
+// import { UserService } from './user.service';
+
+// jest.mock('bcrypt', () => ({
+//   genSalt: jest.fn().mockResolvedValue('mockSalt'),
+//   hash: jest.fn().mockResolvedValue('mockHashedPassword'),
+// }));
+
+// describe('UserService', () => {
+//   let service: UserService;
+//   let prismaService: PrismaService;
+//   let paginationService: PaginationService;
+
+//   beforeEach(async () => {
+//     const module: TestingModule = await Test.createTestingModule({
+//       providers: [
+//         UserService,
+//         {
+//           provide: PrismaService,
+//           useValue: {
+//             user: {
+//               findUnique: jest.fn(),
+//               create: jest.fn(),
+//               update: jest.fn(),
+//               deleteMany: jest.fn(),
+//             },
+//             role_user: {
+//               deleteMany: jest.fn(),
+//               createMany: jest.fn(),
+//             },
+//             createInsensitiveSearch: jest.fn(),
+//           },
+//         },
+//         {
+//           provide: PaginationService,
+//           useValue: {
+//             paginate: jest.fn(),
+//           },
+//         },
+//       ],
+//     }).compile();
+
+//     service = module.get<UserService>(UserService);
+//     prismaService = module.get<PrismaService>(PrismaService);
+//     paginationService = module.get<PaginationService>(PaginationService);
+//   });
+
+//   it('should be defined', () => {
+//     expect(service).toBeDefined();
+//   });
+
+//   describe('listRoles', () => {
+//     it('should return paginated role for a specific user', async () => {
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       const mockPaginatedRoles = {
+//         data: [],
+//         total: 10,
+//         lastPage: 1,
+//         page: 1,
+//         prev: 0,
+//         next: 2,
+//         pageSize: 10,
+//       };
+
+//       jest
+//         .spyOn(paginationService, 'paginate')
+//         .mockResolvedValue(mockPaginatedRoles);
+
+//       const result = await service.listRoles(1, paginationParams);
+
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.role,
+//         paginationParams,
+//         {
+//           include: {
+//             role_user: {
+//               where: { user_id: 1 },
+//               select: { user_id: true, role_id: true },
+//             },
+//           },
+//         },
+//       );
+//       expect(result).toEqual(mockPaginatedRoles);
+//     });
+//   });
+
+//   describe('updateRoles', () => {
+//     it('should update user role', async () => {
+//       const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2] };
+
+//       jest
+//         .spyOn(prismaService.role_user, 'deleteMany')
+//         .mockResolvedValue({ count: 1 });
+//       jest
+//         .spyOn(prismaService.role_user, 'createMany')
+//         .mockResolvedValue({ count: 2 });
+
+//       await service.updateRoles(1, updateIdsDTO);
+
+//       expect(prismaService.role_user.deleteMany).toHaveBeenCalledWith({
+//         where: { user_id: 1 },
+//       });
+//       expect(prismaService.role_user.createMany).toHaveBeenCalledWith({
+//         data: [
+//           { user_id: 1, role_id: 1 },
+//           { user_id: 1, role_id: 2 },
+//         ],
+//         skipDuplicates: true,
+//       });
+//     });
+//   });
+//   /*
+//   describe('getUsers', () => {
+//     it('should return paginated user', async () => {
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       const mockPaginatedUsers = {
+//         data: [],
+//         total: 10,
+//         lastPage: 1,
+//         page: 1,
+//         prev: 0,
+//         next: 2,
+//         pageSize: 10,
+//       };
+
+//       jest.spyOn(prismaService, 'createInsensitiveSearch').mockReturnValue([]);
+//       jest
+//         .spyOn(paginationService, 'paginate')
+//         .mockResolvedValue(mockPaginatedUsers);
+
+//       const result = await service.getUsers(paginationParams);
+
+//       expect(prismaService.createInsensitiveSearch).toHaveBeenCalledWith(
+//         ['name', 'email'],
+//         paginationParams,
+//       );
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.user,
+//         paginationParams,
+//         { where: { OR: [] } },
+//       );
+//       expect(result).toEqual(mockPaginatedUsers);
+//     });
+//   });
+// */
+//   describe('get', () => {
+//     it('should return a specific user by ID', async () => {
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'user@email.com',
+//         password: 'hashedpassword',
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//         multifactor_id: null,
+//         code: null,
+//       };
+//       jest.spyOn(prismaService.user, 'findUnique').mockResolvedValue(mockUser);
+
+//       const result = await service.get(1);
+
+//       expect(prismaService.user.findUnique).toHaveBeenCalledWith({
+//         where: { id: 1 },
+//       });
+//       expect(result).toEqual(mockUser);
+//     });
+//   });
+
+//   describe('hashPassword', () => {
+//     it('should hash the password correctly', async () => {
+//       const password = 'plainPassword';
+//       const result = await service.hashPassword(password);
+
+//       expect(genSalt).toHaveBeenCalledWith(SALT_ROUNDS);
+//       expect(hash).toHaveBeenCalledWith(password, 'mockSalt');
+//       expect(result).toEqual('mockHashedPassword');
+//     });
+//   });
+
+//   describe('create', () => {
+//     it('should create a new user with hashed password', async () => {
+//       const createDTO: CreateDTO = {
+//         email: 'test@test.com',
+//         name: 'Test User',
+//         password: 'password123',
+//       };
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'user@email.com',
+//         password: 'hashedpassword',
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//         multifactor_id: null,
+//         code: null,
+//       };
+
+//       jest.spyOn(prismaService.user, 'create').mockResolvedValue(mockUser);
+
+//       const result = await service.create(createDTO);
+
+//       expect(prismaService.user.create).toHaveBeenCalledWith({
+//         data: {
+//           email: createDTO.email,
+//           name: createDTO.name,
+//           password: 'mockHashedPassword',
+//         },
+//       });
+//       expect(result).toEqual(mockUser);
+//     });
+//   });
+
+//   describe('update', () => {
+//     it('should update an existing user', async () => {
+//       const updateDTO: UpdateDTO = { name: 'Updated User' };
+//       const updateInput = { id: 1, data: updateDTO };
+//       const mockUser = {
+//         id: 1,
+//         name: 'Updated User',
+//         email: 'user@email.com',
+//         password: 'hashedpassword',
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//         multifactor_id: null,
+//         code: null,
+//       };
+//       jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+
+//       const result = await service.update(updateInput);
+
+//       expect(prismaService.user.update).toHaveBeenCalledWith({
+//         where: { id: updateInput.id },
+//         data: updateInput.data,
+//       });
+//       expect(result).toEqual(mockUser);
+//     });
+//   });
+
+//   describe('delete', () => {
+//     it('should throw an error if no ids are provided', async () => {
+//       const deleteDTO: DeleteDTO = { ids: null };
+
+//       await expect(service.delete(deleteDTO)).rejects.toThrow(
+//         new BadRequestException('You must select at least one user to delete.'),
+//       );
+//     });
+
+//     it('should delete user by ids', async () => {
+//       const deleteDTO: DeleteDTO = { ids: [1, 2] };
+
+//       jest
+//         .spyOn(prismaService.user, 'deleteMany')
+//         .mockResolvedValue({ count: 2 });
+
+//       await service.delete(deleteDTO);
+
+//       expect(prismaService.user.deleteMany).toHaveBeenCalledWith({
+//         where: {
+//           id: { in: deleteDTO.ids },
+//           email: { not: { startsWith: 'root@' } },
+//         },
+//       });
+//     });
+//   });
+// });

package/src/user/user.service.ts

@@ -0,0 +1,269 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService, user } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    Inject,
+    Injectable,
+    NotFoundException,
+    forwardRef,
+} from '@nestjs/common';
+import { ChallengeService } from '../challenge/challenge.service';
+import { DeleteDTO } from '../dto/delete.dto';
+import { FileService } from '../file/file.service';
+import { SecurityService } from '../security/security.service';
+import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class UserService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => SecurityService))
+    private readonly security: SecurityService,
+    @Inject(forwardRef(() => ChallengeService))
+    private readonly challenge: ChallengeService,
+    @Inject(forwardRef(() => FileService))
+    private readonly file: FileService
+  ) { }
+
+  async delete(locale: string, {ids}: DeleteDTO) {
+    if (!ids || ids.length === 0) {
+      throw new BadRequestException(getLocaleText('userIdsRequired', locale, 'At least one User ID is required to delete users.'));
+    }
+    const deleteResult = await this.prismaService.user.deleteMany({
+      where: {
+        id: { in: ids },
+      },
+    });
+    return deleteResult;
+  }
+  
+  async update(
+    locale: string,
+    userId: number,
+    {name}: UpdateDTO,
+  ) {
+    const user = await this.findUserById(locale, userId);
+
+    const updatedUser = await this.prismaService.user.update({
+      where: { id: user.id },
+      data: {
+        name: name ?? user.name,
+      },
+    });
+
+    return updatedUser;
+
+  }
+
+  async get(locale: string, userId: number) {
+    return this.findUserById(locale, userId);
+  }
+
+  async changeAvatar(userId: number, avatar: MulterFile){
+    const userFound = await this.prismaService.user.findUnique({
+      where: {
+        id: userId,
+      },
+    });
+
+    if (!userFound) {
+      throw new BadRequestException(getLocaleText('userNotFound', 'en', 'User not found'));
+    }
+
+    let photo_id = userFound.photo_id;
+    const file = await this.file.upload('user/avatar', avatar);
+    if (userFound.photo_id > 0 && file.id > 0) {
+      try {
+        await this.file.delete({ ids: [userFound.photo_id] });
+      } catch (error) {
+        this.prismaService.file.delete({
+          where: { id: userFound.photo_id },
+        });
+        console.warn('Erro ao deletar avatar antigo:', error);
+      }
+    }
+
+    photo_id = file.id;
+    await this.prismaService.user.update({
+      where: { id: userId },
+      data: {
+        photo_id,
+      },
+    });
+
+    return {
+      id: file.id,
+      path: file.path,
+    };
+  }
+
+  async list(paginationParams) {
+    // Campos válidos para ordenação e busca
+    const validSortFields = [
+      'id',
+      'name',
+      'photo_id',
+      'suspended_until',
+      'suspended_reason',
+      'deactivated_at',
+      'created_at',
+      'updated_at',
+    ];
+    const searchFields = ['name'];
+
+    const paginate = await this.paginationService.paginatePrismaModel(this.prismaService.user, {
+      ...paginationParams,
+      validSortFields,
+      searchFields,
+      include: {
+        user_account: true,
+        user_credential: true,
+        user_identifier: true,
+        user_mfa: true,
+        user_activity: {
+          orderBy: {
+            created_at: 'desc',
+          },
+        },
+        user_session: { 
+          where: {
+            revoked_at: null,
+            expires_at: {
+              gt: new Date(),
+            }
+          },
+          orderBy: {
+            created_at: 'desc',
+          },
+        },
+      },
+    });
+
+    // Estatísticas solicitadas:
+    // - total de usuários
+    // - total de usuários novos nos últimos 7 dias (baseado em created_at)
+    // - total de usuários bloqueados (baseado em suspended_until > agora)
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+    const now = new Date();
+
+    const [totalUsers, newUsersLast7Days, blockedUsers] = await this.prismaService.$transaction([
+      this.prismaService.user.count(),
+      this.prismaService.user.count({ where: { created_at: { gte: sevenDaysAgo } } }),
+      this.prismaService.user.count({ where: { suspended_until: { gt: now } } }),
+    ]);
+
+    return {
+      paginate,
+      stats: {
+        total: totalUsers,
+        newLast7Days: newUsersLast7Days,
+        blocked: blockedUsers,
+      },
+    };
+  }
+
+  async createWithEmailAndPassword(
+      locale: string,
+      { email, name, password }: CreateWithEmailAndPasswordDTO,
+    ) {
+      if (await this.findUserByEmail(locale, email)) {
+        throw new BadRequestException(getLocaleText('signup.emailExists', locale, 'Email already in use.'));
+      }
+  
+      const passwordHash = await this.security.hashArgon2(password);
+  
+      const user = await this.prismaService.$transaction(async (tx) => {
+        const role = await tx.role.findFirst({
+          where: { slug: 'user' },
+          select: { id: true },
+        });
+  
+        if (!role) {
+          throw new BadRequestException(getLocaleText('defaultRoleNotFound', locale, 'Default user role not found.'));
+        }
+  
+        const user = await tx.user.create({
+          data: {
+            name,
+            user_identifier: { create: { type: 'email', value: email } },
+            user_credential: { create: { type: 'password', hash: passwordHash } },
+            user_mfa: {
+              create: {
+                name: getLocaleText('defaultNameMfaEmail', locale, 'Default E-mail MFA'),
+                type: 'email',
+                user_mfa_email: { create: { email } },
+              },
+            },
+            role_user: {
+              create: {
+                role_id: role.id
+              }
+            }
+          },
+        });
+  
+        return user;
+      });
+  
+      const challenge = await this.challenge.verifyEmail(locale, user.id, email);
+      await this.registerUserActivity(user.id, "register")
+      return { user, challenge };
+    }
+
+    async findUserById(locale: string, id: number) {
+    const user = await this.prismaService.user.findUnique({
+      where: { id },
+      include: {
+        user_identifier: true,
+        user_credential: true,
+        user_activity: true,
+        user_session: true,
+        user_account: true
+      }
+    });
+
+    if (!user) {
+      throw new NotFoundException(getLocaleText('userNotFound', locale, 'User not found'));
+    }
+
+    return user;
+  }
+
+  async findUserByEmail(locale: string, email: string): Promise<user | null>  {
+    const user = await this.prismaService.user.findFirst({
+      where: {
+        user_identifier: {
+          some: {
+            type: 'email',
+            value: email.toLowerCase().trim()
+          }
+        }
+      },
+      include: {
+        user_identifier: true,
+        user_credential: true,
+        user_session: true
+      }
+    })
+
+    if (!user) {
+      return null
+    }
+
+    return user;
+  }
+
+  async registerUserActivity(userId: number, action: string){
+    return this.prismaService.user_activity.create({
+      data: {
+        user_id: userId,
+        action
+      }
+    })
+  }
+}

package/src/utils/locale-context.ts

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+interface LocaleContext {
+  locale: string;
+}
+
+export const localeStorage = new AsyncLocalStorage<LocaleContext>();
+
+export function getLocaleFromContext(): string {
+  const context = localeStorage.getStore();
+  return context?.locale || 'en';
+}

package/src/validators/is-email-with-settings.validator.ts

@@ -0,0 +1,82 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { Injectable } from '@nestjs/common';
+import {
+  registerDecorator,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface
+} from 'class-validator';
+import { SettingService } from '../setting/setting.service';
+import { getLocaleFromContext } from '../utils/locale-context';
+
+@ValidatorConstraint({ async: true })
+@Injectable()
+export class IsEmailWithSettingsConstraint
+  implements ValidatorConstraintInterface
+{
+  constructor(private readonly settingService: SettingService) {}
+
+  async validate(email: string): Promise<boolean> {
+    if (!email) {
+      return false;
+    }
+
+    // Validate email format (basic regex)
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+      return false;
+    }
+
+    // Extract domain from email
+    const domain = email.split('@')[1]?.toLowerCase();
+    if (!domain) {
+      return false;
+    }
+
+    const settings = await this.settingService.getSystemSettings();
+    const blacklist = settings.setting['email-host-blacklist'] || [];
+    const whitelist = settings.setting['email-host-whitelist'] || [];
+
+    // blacklist e whitelist já são arrays
+    const blacklistHosts = Array.isArray(blacklist)
+      ? blacklist.map((host: string) => host.trim().toLowerCase()).filter((host: string) => host.length > 0)
+      : [];
+
+    const whitelistHosts = Array.isArray(whitelist)
+      ? whitelist.map((host: string) => host.trim().toLowerCase()).filter((host: string) => host.length > 0)
+      : [];
+
+    // If whitelist is defined and not empty, domain must be in whitelist
+    if (whitelistHosts.length > 0) {
+      return whitelistHosts.includes(domain);
+    }
+
+    // If blacklist is defined, domain must not be in blacklist
+    if (blacklistHosts.length > 0) {
+      return !blacklistHosts.includes(domain);
+    }
+
+    // No restrictions, email is valid
+    return true;
+  }
+
+  defaultMessage(): string {
+    return getLocaleText(
+      'email.invalidEmail',
+      getLocaleFromContext(),
+      'Email does not meet the security requirements defined in system settings.'
+    );
+  }
+}
+
+export function IsEmailWithSettings(validationOptions?: ValidationOptions) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      constraints: [],
+      validator: IsEmailWithSettingsConstraint,
+    });
+  };
+}