@hedhog/admin 0.0.104 → 0.0.106

package/src/screen/screen.service.spec.ts

@@ -0,0 +1,298 @@
+import {
+  PageOrderDirection,
+  PaginationDTO,
+  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 { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { ScreenService } from './screen.service';
+
+describe('ScreenService', () => {
+  let service: ScreenService;
+  let prismaService: PrismaService;
+  let paginationService: PaginationService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ScreenService,
+        {
+          provide: PrismaService,
+          useValue: {
+            screens: {
+              create: jest.fn(),
+              update: jest.fn(),
+              deleteMany: jest.fn(),
+              findUnique: jest.fn(),
+            },
+            route: {
+              findMany: jest.fn(),
+            },
+            role_screen: {
+              deleteMany: jest.fn(),
+              createMany: jest.fn(),
+            },
+            route_screens: {
+              deleteMany: jest.fn(),
+              createMany: jest.fn(),
+            },
+            createInsensitiveSearch: jest.fn(),
+          },
+        },
+        {
+          provide: PaginationService,
+          useValue: {
+            paginate: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<ScreenService>(ScreenService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('create', () => {
+    it('should create a screen', async () => {
+      const createDTO = {
+        name: 'Test Screen',
+        slug: 'test-screen',
+        description: 'This is a test screen',
+        icon: 'test-icon',
+      };
+
+      jest
+        .spyOn(prismaService.screens, 'create')
+        .mockResolvedValue(createDTO as any);
+
+      const result = await service.create(createDTO);
+
+      expect(prismaService.screens.create).toHaveBeenCalledWith({
+        data: createDTO,
+      });
+      expect(result).toEqual(createDTO);
+    });
+  });
+
+  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 screen to delete.`,
+        ),
+      );
+    });
+
+    it('should delete screens by ids', async () => {
+      const deleteDTO: DeleteDTO = { ids: [1, 2] };
+
+      jest.spyOn(prismaService.screens, 'deleteMany').mockResolvedValue({
+        count: 2,
+      });
+
+      await service.delete(deleteDTO);
+
+      expect(prismaService.screens.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: deleteDTO.ids } },
+      });
+    });
+  });
+
+  describe('update', () => {
+    it('should update a screen', async () => {
+      const updateDTO = {
+        id: 1,
+        name: 'Updated Screen',
+        slug: 'updated-screen',
+        icon: 'update-icon',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      const updateInput = { id: 1, data: updateDTO };
+
+      jest.spyOn(prismaService.screens, 'update').mockResolvedValue(updateDTO);
+
+      const result = await service.update(updateInput);
+
+      expect(prismaService.screens.update).toHaveBeenCalledWith({
+        where: { id: updateInput.id },
+        data: updateInput.data,
+      });
+      expect(result).toEqual(updateDTO);
+    });
+  });
+
+  describe('get', () => {
+    it('should get a screen by id', async () => {
+      const screen = {
+        id: 1,
+        name: 'Updated Screen',
+        slug: 'updated-screen',
+        icon: 'update-icon',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+
+      jest.spyOn(prismaService.screens, 'findUnique').mockResolvedValue(screen);
+
+      const result = await service.get(1);
+
+      expect(prismaService.screens.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 },
+      });
+      expect(result).toEqual(screen);
+    });
+  });
+
+  describe('updateRoles', () => {
+    it('should update role for a screen', async () => {
+      const screenId = 1;
+      const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2, 3] };
+      jest.spyOn(prismaService.role_screen, 'deleteMany').mockResolvedValue({
+        count: 1,
+      });
+
+      jest.spyOn(prismaService.role_screen, 'createMany').mockResolvedValue({
+        count: updateIdsDTO.ids.length,
+      });
+
+      await service.updateRoles(screenId, updateIdsDTO);
+
+      expect(prismaService.role_screen.deleteMany).toHaveBeenCalledWith({
+        where: { screen_id: screenId },
+      });
+      expect(prismaService.role_screen.createMany).toHaveBeenCalledWith({
+        data: updateIdsDTO.ids.map((roleId) => ({
+          screen_id: screenId,
+          role_id: roleId,
+        })),
+        skipDuplicates: true,
+      });
+    });
+  });
+
+  describe('updateRoutes', () => {
+    it('should delete existing route_screens and create new ones', async () => {
+      const screenId = 1;
+      const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2, 3] };
+
+      prismaService.route.findMany = jest
+        .fn()
+        .mockResolvedValue([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+      prismaService.route_screens.deleteMany = jest.fn();
+      prismaService.route_screens.createMany = jest.fn();
+
+      await service.updateRoutes(screenId, updateIdsDTO);
+
+      expect(prismaService.route.findMany).toHaveBeenCalledWith({
+        where: { id: { in: updateIdsDTO.ids } },
+        select: { id: true },
+      });
+
+      expect(prismaService.route_screens.deleteMany).toHaveBeenCalledWith({
+        where: { screen_id: screenId },
+      });
+
+      expect(prismaService.route_screens.createMany).toHaveBeenCalledWith({
+        data: updateIdsDTO.ids.map((routeId) => ({
+          screen_id: screenId,
+          route_id: routeId,
+        })),
+        skipDuplicates: true,
+      });
+    });
+  });
+
+  describe('listRoles', () => {
+    it('should call paginate method with correct parameters', async () => {
+      const locale = 'en';
+      const screenId = 1;
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      paginationService.paginate = jest.fn().mockResolvedValue({
+        data: [],
+        total: 0,
+      });
+
+      await service.listRoles(locale, screenId, paginationParams);
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.role,
+        paginationParams,
+        {
+          include: {
+            role_screen: {
+              where: {
+                screen_id: screenId,
+              },
+              select: {
+                role_id: true,
+                screen_id: true,
+              },
+            },
+          },
+        },
+      );
+    });
+  });
+
+  describe('listRoutes', () => {
+    it('should paginate the route linked to a screen', async () => {
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+      const screenId = 1;
+      const mockPaginationResult = {
+        data: [],
+        total: 10,
+        lastPage: 1,
+        page: 1,
+        prev: 0,
+        next: 2,
+        pageSize: 10,
+      };
+
+      jest
+        .spyOn(paginationService, 'paginate')
+        .mockResolvedValue(mockPaginationResult);
+
+      await service.listRoutes(screenId, paginationParams);
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.route,
+        paginationParams,
+        {
+          include: {
+            route_screens: {
+              where: { screen_id: screenId },
+              select: { route_id: true, screen_id: true },
+            },
+          },
+        },
+      );
+    });
+  });
+});

package/src/screen/screen.service.ts

@@ -0,0 +1,181 @@
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/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 ScreenService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async updateRoles(screenId: number, data: UpdateIdsDTO) {
+    await this.prismaService.role_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return this.prismaService.role_screen.createMany({
+      data: data.ids.map((roleId) => ({
+        screen_id: screenId,
+        role_id: roleId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async updateRoutes(screenId: number, { ids }: UpdateIdsDTO) {
+    ids = (
+      await this.prismaService.route.findMany({
+        where: {
+          id: {
+            in: ids,
+          },
+        },
+        select: {
+          id: true,
+        },
+      })
+    ).map((route) => route.id);
+
+    await this.prismaService.route_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return this.prismaService.route_screen.createMany({
+      data: ids.map((routeId) => ({
+        screen_id: screenId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async listRoutes(screenId: number, paginationParams: PaginationDTO) {
+    return this.paginationService.paginate(
+      this.prismaService.route,
+      paginationParams,
+      {
+        include: {
+          route_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              route_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async listRoles(
+    locale: string,
+    screenId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        include: {
+          role_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              role_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'icon'];
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+
+    return result;
+  }
+
+  async get(screenId: number) {
+    return this.prismaService.screen.findUnique({ where: { id: screenId } });
+  }
+
+  async create({ name, slug, description, icon }: CreateDTO) {
+    return this.prismaService.screen.create({
+      data: {
+        name,
+        slug,
+        description,
+        icon,
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.screen.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one screen to delete.`,
+      );
+    }
+
+    return this.prismaService.screen.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/setting/dto/create.dto.ts

@@ -0,0 +1 @@
+export class CreateDTO {}

package/src/setting/dto/setting-user.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class SettingUserDTO {
+  @IsString()
+  value: string;
+}

package/src/setting/dto/setting.dto.ts

@@ -0,0 +1,17 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+
+class Setting {
+  @IsString()
+  slug: string;
+
+  @IsString()
+  value: string;
+}
+
+export class SettingDTO {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Setting)
+  setting: Setting[];
+}

package/src/setting/dto/update.dto.ts

@@ -0,0 +1,3 @@
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends CreateDTO {}

package/src/setting/setting.controller.ts

@@ -0,0 +1,100 @@
+import { Pagination } from '@hedhog/pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Put,
+  forwardRef,
+} from '@nestjs/common';
+import { User } from '../auth/decorators/user.decorator';
+import { DeleteDTO } from '../dto/delete.dto';
+import { Locale } from '../locale';
+import { Role } from '../role/decorators/role.decorator';
+import { CreateDTO } from './dto/create.dto';
+import { SettingUserDTO } from './dto/setting-user.dto';
+import { SettingDTO } from './dto/setting.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { SettingService } from './setting.service';
+
+@Role()
+@Controller('setting')
+export class SettingsController {
+  constructor(
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) {}
+
+  @Get('group/:slug')
+  async getSettingFromGroup(
+    @Pagination() paginationParams,
+    @Locale() locale,
+    @Param('slug') slug: string,
+  ) {
+    return this.settingService.getSettingFromGroup(
+      locale,
+      paginationParams,
+      slug,
+    );
+  }
+
+  @Get('group')
+  async listSettingGroups(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettingGroups(locale, paginationParams);
+  }
+
+  @Get()
+  async listSettings(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettings(locale, paginationParams);
+  }
+
+  @Get(':settingId')
+  async show(@Param('settingId', ParseIntPipe) settingId: number) {
+    return this.settingService.get(settingId);
+  }
+
+  @Post()
+  create(@Body() data: CreateDTO) {
+    return this.settingService.create(data);
+  }
+
+  @Put('user/:slug')
+  async updateUserFromSlug(
+    @Param('slug') slug: string,
+    @Body() { value }: SettingUserDTO,
+    @User() { id },
+  ) {
+    return this.settingService.setSettingUserValue(id, slug, value);
+  }
+
+  @Put(':slug')
+  async updateFromSlug(@Param('slug') slug: string, @Body() data: UpdateDTO) {
+    return this.settingService.updateFromSlug(slug, data);
+  }
+
+  @Put()
+  async setManySettings(@Body() data: SettingDTO) {
+    return this.settingService.setManySettings(data);
+  }
+
+  @Patch(':settingId')
+  async update(
+    @Param('settingId', ParseIntPipe) settingId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.settingService.update({
+      id: settingId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.settingService.delete(data);
+  }
+}

package/src/setting/setting.module.ts

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