@hedhog/admin 0.0.109 → 0.0.111

package/src/setting/setting.controller.ts

@@ -1,107 +0,0 @@
-import { Pagination } from '@hedhog/pagination';
-import {
-  Body,
-  Controller,
-  Delete,
-  forwardRef,
-  Get,
-  Inject,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-  Put,
-  Res,
-} from '@nestjs/common';
-import { Locale } from '@hedhog/locale';
-import { Role, Public } from '@hedhog/utils';
-import { User } from '../auth/decorators/user.decorator';
-import { DeleteDTO } from '../dto/delete.dto';
-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,
-    );
-  }
-
-  @Public()
-  @Get('appearance.css')
-  async appearanceCSS(@Res() res) {
-    return this.settingService.getAppearanceCSS(res);
-  }
-
-  @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()
-  async 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

@@ -1,20 +0,0 @@
-import { FileModule } from '@hedhog/file';
-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),
-    forwardRef(() => FileModule),
-  ],
-})
-export class SettingModule {}

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

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