@hedhog/admin 0.0.108 → 0.0.110

package/src/locale/locale.service.ts

@@ -1,364 +0,0 @@
-import { PaginationDTO, PaginationService } from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  forwardRef,
-} from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { DeleteDTO } from './dto/delete.dto';
-import { UpdateDTO } from './dto/update.dto';
-
-@Injectable()
-export class LocaleService {
-  private codes: any = {};
-
-  constructor(
-    @Inject(forwardRef(() => PrismaService))
-    private readonly prismaService: PrismaService,
-    @Inject(forwardRef(() => PaginationService))
-    private readonly paginationService: PaginationService,
-  ) {}
-
-  async setEnabled(codes: string[]) {
-    if (!codes || codes.length < 1) {
-      throw new BadRequestException('You must select at least one item code.');
-    }
-
-    await this.prismaService.locale.updateMany({
-      where: {
-        enabled: true,
-      },
-      data: {
-        enabled: false,
-      },
-    });
-
-    return this.prismaService.locale.updateMany({
-      where: {
-        code: {
-          in: codes,
-        },
-      },
-      data: {
-        enabled: true,
-      },
-    });
-  }
-
-  async getEnables(currentLocale: string, paginationParams: PaginationDTO) {
-    const fields = ['code', 'region'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    const result = await this.paginationService.paginate(
-      this.prismaService.locale,
-      paginationParams,
-      {
-        where: {
-          AND: [
-            {
-              enabled: true,
-            },
-            {
-              OR,
-            },
-          ],
-        },
-      },
-    );
-
-    const codes = [];
-
-    for (const item of result.data) {
-      codes.push((item as any).code);
-    }
-
-    const { code, region, locale } = this.parseLocale(currentLocale);
-
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: 'translation',
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    for (let i = 0; i < result.data.length; i++) {
-      for (const value of values) {
-        if (value.name === (result.data[i] as any).code) {
-          (result.data[i] as any).name = value.value;
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  parseLocale(locale: string) {
-    const localeCodes = locale.toLowerCase().split('-');
-    const code = localeCodes[0];
-    const region = localeCodes[1];
-    return {
-      code,
-      region,
-      locale: localeCodes,
-    };
-  }
-
-  async getTranslations(localeCode: string, namespace: string) {
-    if (!localeCode) {
-      throw new BadRequestException('Locale code is required.');
-    }
-
-    if (!namespace) {
-      namespace = 'translation';
-    }
-
-    const { code, region, locale } = this.parseLocale(localeCode);
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: namespace,
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    const translation = {};
-
-    for (const value of values) {
-      translation[value.name] = value.value;
-    }
-
-    return translation;
-  }
-
-  async get(currentLocale: string, paginationParams: PaginationDTO) {
-    const fields = ['code', 'region'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    const result = await this.paginationService.paginate(
-      this.prismaService.locale,
-      paginationParams,
-      {
-        where: {
-          OR,
-        },
-      },
-    );
-
-    const codes = [];
-
-    for (const item of result.data) {
-      codes.push((item as any).code);
-    }
-
-    const { code, region, locale } = this.parseLocale(currentLocale);
-
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: 'translation',
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    for (let i = 0; i < result.data.length; i++) {
-      for (const value of values) {
-        if (value.name === (result.data[i] as any).code) {
-          (result.data[i] as any).name = value.value;
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  async getByCode(code: string) {
-    if (this.codes[code]) {
-      return this.codes[code];
-    }
-    return (this.codes[code] = await this.prismaService.locale.findFirst({
-      where: { code },
-    }));
-  }
-
-  async getById(localeId: number) {
-    return this.prismaService.locale.findUnique({
-      where: { id: localeId },
-    });
-  }
-
-  async create(data: CreateDTO) {
-    return this.prismaService.locale.create({
-      data,
-    });
-  }
-
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.locale.update({
-      where: { id },
-      data,
-    });
-  }
-
-  async delete({ ids }: DeleteDTO) {
-    if (ids == undefined || ids == null) {
-      throw new BadRequestException(
-        'You must select at least one item to delete.',
-      );
-    }
-
-    return this.prismaService.locale.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
-    });
-  }
-
-  private getTableNameTranslations(modelName: string) {
-    return `${modelName}_locale`;
-  }
-
-  async createModelWithLocale<T>(
-    modelName: string,
-    foreignKeyName: string,
-    data: T,
-    locale: Record<string, Record<string, string>>,
-  ) {
-    try {
-      const model = await this.prismaService[modelName].create({ data });
-
-      if (locale) {
-        await Promise.all(
-          Object.entries(locale).map(async ([localeCode, localeData]) => {
-            const localeRecord = await this.getByCode(localeCode);
-            const localeEntry = {
-              [foreignKeyName]: model.id,
-              locale_id: localeRecord.id,
-              ...localeData,
-            };
-
-            await this.prismaService[
-              this.getTableNameTranslations(modelName)
-            ].create({
-              data: localeEntry,
-            });
-          }),
-        );
-      }
-
-      return this.prismaService[modelName].findUnique({
-        where: { id: model.id },
-        include: {
-          [this.getTableNameTranslations(modelName)]: {
-            where: { locale: { enabled: true } },
-            include: { locale: { select: { code: true } } },
-          },
-        },
-      });
-    } catch (error: any) {
-      if (error.message.includes('Unique constraint failed')) {
-        throw new BadRequestException('Data already exists.');
-      } else {
-        throw new BadRequestException(error);
-      }
-    }
-  }
-
-  async updateModelWithLocale<T>(
-    modelName: string,
-    foreignKeyName: string,
-    id: number,
-    data: T,
-    locale: Record<string, Record<string, string>>,
-  ) {
-    try {
-      if (locale) {
-        await Promise.all(
-          Object.entries(locale).map(async ([localeCode, localeData]) => {
-            const localeRecord = await this.getByCode(localeCode);
-            const localeEntry = {
-              [foreignKeyName]: id,
-              locale_id: localeRecord.id,
-              ...localeData,
-            };
-
-            await this.prismaService[
-              this.getTableNameTranslations(modelName)
-            ].upsert({
-              where: {
-                [`${foreignKeyName}_locale_id`]: {
-                  [foreignKeyName]: id,
-                  locale_id: localeRecord.id,
-                },
-              },
-              create: localeEntry,
-              update: localeData,
-            });
-          }),
-        );
-      }
-
-      return this.prismaService[modelName].update({
-        where: { id },
-        data,
-      });
-    } catch (error: any) {
-      if (error.message.includes('Unique constraint failed')) {
-        throw new BadRequestException('Data already exists.');
-      } else {
-        throw new BadRequestException(error);
-      }
-    }
-  }
-}

package/src/role/decorators/role.decorator.ts

@@ -1,7 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-
-export const WITH_ROLE = 'withRole';
-
-export function Role() {
-  return SetMetadata(WITH_ROLE, true);
-}

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

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

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

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

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

@@ -1,17 +0,0 @@
-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

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

package/src/setting/setting.controller.ts

@@ -1,100 +0,0 @@
-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()
-  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,18 +0,0 @@
-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 {}

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 } },
-      });
-    });
-  });
-});