@hedhog/admin 0.0.103 → 0.0.105

package/src/setting/setting.service.spec.ts

@@ -0,0 +1,183 @@
+import { PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { SettingService } from './setting.service';
+
+describe('SettingService', () => {
+  let service: SettingService;
+  let prismaService: PrismaService;
+  // let paginationService: PaginationService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        SettingService,
+        {
+          provide: PrismaService,
+          useValue: {
+            setting: {
+              findUnique: jest.fn(),
+              create: jest.fn(),
+              update: jest.fn(),
+              deleteMany: jest.fn(),
+            },
+            createInsensitiveSearch: jest.fn(),
+          },
+        },
+        {
+          provide: PaginationService,
+          useValue: {
+            paginate: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<SettingService>(SettingService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    // paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  /* describe('getSettings', () => {
+    it('should return paginated setting', async () => {
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      const mockPaginatedData = {
+        data: [],
+        total: 10,
+        lastPage: 1,
+        page: 1,
+        prev: 0,
+        next: 2,
+        pageSize: 10,
+      };
+
+      jest.spyOn(prismaService, 'createInsensitiveSearch').mockReturnValue([]);
+      jest
+        .spyOn(paginationService, 'paginate')
+        .mockResolvedValue(mockPaginatedData);
+
+      const result = await service.getSettings(paginationParams);
+
+      expect(prismaService.createInsensitiveSearch).toHaveBeenCalledWith(
+        ['name'],
+        paginationParams,
+      );
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.setting,
+        paginationParams,
+        { where: { OR: [] } },
+      );
+      expect(result).toEqual(mockPaginatedData);
+    });
+  });*/
+
+  describe('get', () => {
+    it('should return a specific setting by ID', async () => {
+      const mockSetting = {
+        id: 1,
+        name: 'Test Setting',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest
+        .spyOn(prismaService.setting, 'findUnique')
+        .mockResolvedValue(mockSetting);
+
+      const result = await service.get(1);
+
+      expect(prismaService.setting.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 },
+      });
+      expect(result).toEqual(mockSetting);
+    });
+  });
+  /*
+  describe('create', () => {
+    it('should create a new setting', async () => {
+      const createDTO: CreateDTO = { name: 'New Setting' };
+      const mockSetting = {
+        id: 1,
+        name: 'Test Setting',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+
+      jest
+        .spyOn(prismaService.setting, 'create')
+        .mockResolvedValue(mockSetting);
+
+      const result = await service.create(createDTO);
+
+      expect(prismaService.setting.create).toHaveBeenCalledWith({
+        data: { name: createDTO.name },
+      });
+      expect(result).toEqual(mockSetting);
+    });
+  });*/
+
+  describe('update', () => {
+    it('should update an existing setting', async () => {
+      const updateDTO: UpdateDTO = { name: 'Updated Setting' };
+      const updateInput = { id: 1, data: updateDTO };
+      const mockSetting = {
+        id: 1,
+        name: 'Update Setting',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+
+      jest
+        .spyOn(prismaService.setting, 'update')
+        .mockResolvedValue(mockSetting);
+
+      const result = await service.update(updateInput);
+
+      expect(prismaService.setting.update).toHaveBeenCalledWith({
+        where: { id: updateInput.id },
+        data: updateInput.data,
+      });
+      expect(result).toEqual(mockSetting);
+    });
+  });
+
+  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 setting to delete.`,
+        ),
+      );
+    });
+
+    it('should delete setting by ids', async () => {
+      const deleteDTO: DeleteDTO = { ids: [1, 2] };
+
+      jest
+        .spyOn(prismaService.setting, 'deleteMany')
+        .mockResolvedValue({ count: 2 });
+
+      await service.delete(deleteDTO);
+
+      expect(prismaService.setting.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: deleteDTO.ids } },
+      });
+    });
+  });
+});

package/src/setting/setting.service.ts

@@ -0,0 +1,346 @@
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { itemTranslations } from '@hedhog/utils';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { CreateDTO } from './dto/create.dto';
+import { SettingDTO } from './dto/setting.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class SettingService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async setManySettings(data: SettingDTO) {
+    for (const { slug, value } of data.setting) {
+      await this.prismaService.setting.updateMany({
+        where: {
+          slug,
+        },
+        data: {
+          value,
+        },
+      });
+    }
+
+    return { success: true };
+  }
+
+  async getSettingFromGroup(locale: any, paginationParams: any, slug: string) {
+    const fields = ['slug', 'value'];
+
+    paginationParams.pageSize = 100;
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting,
+      paginationParams,
+      {
+        where: {
+          AND: {
+            setting_group: {
+              slug,
+            },
+            OR,
+          },
+        },
+        include: {
+          setting_group: {
+            include: {
+              setting_group_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
+          setting_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_locale',
+    );
+
+    result.data = result.data.map((setting: any) => {
+      setting.setting_group = itemTranslations(
+        'setting_group_locale',
+        setting.setting_group,
+      );
+      return setting;
+    });
+
+    return result;
+  }
+
+  async getSettingGroups(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'icon'];
+
+    paginationParams.pageSize = 100;
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting_group,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          setting_group_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_group_locale',
+    );
+
+    return result;
+  }
+
+  async getSettings(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'value'];
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          setting_group: {
+            include: {
+              setting_group_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
+          setting_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_locale',
+    );
+
+    result.data = result.data.map((setting: any) => {
+      setting.setting_group = itemTranslations(
+        'setting_group_locale',
+        setting.setting_group,
+      );
+      return setting;
+    });
+
+    return result;
+  }
+
+  async get(settingId: number) {
+    return this.prismaService.setting.findUnique({
+      where: { id: settingId },
+    });
+  }
+
+  async create({}: CreateDTO) {
+    return this.prismaService.setting.create({
+      data: {},
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.setting.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async updateFromSlug(slug: string, data: UpdateDTO) {
+    const { id } = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+      },
+    });
+
+    if (!id) {
+      throw new BadRequestException(`Setting with slug ${slug} not found.`);
+    }
+
+    return this.update({
+      id,
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one setting to delete.`,
+      );
+    }
+
+    return this.prismaService.setting.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async setSettingUserValue(user_id: number, slug: string, value: string) {
+    const user = await this.prismaService.user.findUnique({
+      where: {
+        id: user_id,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!user) {
+      throw new BadRequestException(`User with id ${user_id} not found.`);
+    }
+
+    const setting = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+        user_override: true,
+      },
+    });
+
+    if (!setting) {
+      throw new BadRequestException(
+        `Setting with slug ${slug} not found or user can not override.`,
+      );
+    }
+
+    return await this.prismaService.setting_user.upsert({
+      where: {
+        user_id_setting_id: {
+          setting_id: setting.id,
+          user_id: user.id,
+        },
+      },
+      create: {
+        setting_id: setting.id,
+        value,
+        user_id: user.id,
+      },
+      update: {
+        value,
+      },
+      select: {
+        setting_id: true,
+        user_id: true,
+        value: true,
+      },
+    });
+  }
+
+  async getSettingValues(slug: string | string[]) {
+    slug = Array.isArray(slug) ? slug : [slug];
+
+    let setting = await this.prismaService.setting.findMany({
+      where: {
+        slug: {
+          in: slug,
+        },
+      },
+      select: {
+        id: true,
+        value: true,
+        slug: true,
+        type: true,
+        user_override: true,
+      },
+    });
+
+    const slugUserOverride = setting.filter((setting) => setting.userOverride);
+
+    const settingUser = await this.prismaService.setting_user.findMany({
+      where: {
+        setting_id: {
+          in: slugUserOverride.map((setting) => setting.id),
+        },
+      },
+      select: {
+        value: true,
+        setting_id: true,
+      },
+    });
+
+    const data: Record<string, any> = {};
+
+    setting.forEach((setting) => {
+      data[setting.slug] = setting.value;
+    });
+
+    settingUser.forEach((setting) => {
+      data[slugUserOverride.find((s) => s.id === setting.setting_id).slug] =
+        setting.value;
+    });
+
+    return data;
+  }
+}

package/src/types/http-method.ts

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

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

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

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

package/src/user/user.controller.ts

@@ -0,0 +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 '../role/decorators/role.decorator';
+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 getUsers(@Pagination() paginationParams) {
+    return this.userService.getUsers(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 show(@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);
+  }
+}

package/src/user/user.module.ts

@@ -0,0 +1,18 @@
+import { PaginationModule } from '@hedhog/pagination';
+import { PrismaModule } from '@hedhog/prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+import { AuthModule } from '../auth/auth.module';
+
+@Module({
+  providers: [UserService],
+  exports: [UserService],
+  controllers: [UserController],
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+})
+export class UserModule {}